usr.bin/dtc/fdt.hh

59 class node;
74  * Owning pointer to a node.
76 typedef std::unique_ptr<node> node_ptr;
134 		 * the full path of the target node.  */
138 		 * string_data will contain the node label for the target and,
141 		 * property of the target node.
300 	 * Parses a reference.  This is a node label preceded by an ampersand
301 	 * symbol, which should expand to the full path to that node.
304 	 * a node name, however dtc assumes that it is a label, and so we
406  * Class encapsulating a device tree node.  Nodes may contain properties and
409 class node
413 	 * The labels for this node, if any.  Node labels are used as the
418 	 * The name of the node.
422 	 * The name of the node is a path reference.
426 	 * The unit address of the node, which is optionally written after the
431 	 * A flag indicating that this node has been marked /omit-if-no-ref/ and
433 	 * by a node that is not similarly denoted.
437 	 * A flag indicating that this node has been referenced, either directly
438 	 * or indirectly, by a node that is not marked /omit-if-no-ref/.
474 		child_range(node &nd) : n(nd) {}
478 		node &n;
485 		property_range(node &nd) : n(nd) {}
489 		node &n;
492 	 * The properties contained within this node.
496 	 * The children of this node.
500 	 * Children that should be deleted from this node when merging.
504 	 * Properties that should be deleted from this node when merging.
508 	 * A flag indicating whether this node is valid.  This is set to false
513 	 * Parses a name inside a node, writing the string passed as the last
520 	 * Constructs a new node from two input buffers, pointing to the struct
523 	node(input_buffer &structs, input_buffer &strings);
525 	 * Parses a new node from the specified input buffer.  This is called
527 	 * node.  The name, and optionally label and unit address, should have
530 	node(text_input_buffer &input,
537 	 * Creates a special node with the specified name and properties.
539 	node(const std::string &n, const std::vector<property_ptr> &p);
558 	 * Sorts the node's properties and children into alphabetical order and
563 	 * Returns an iterator for the first child of this node.
570 	 * Returns an iterator after the last child of this node.
578 	 * the children of this node.
600 	 * the properties of this node.
607 	 * Returns an iterator after the last property of this node.
614 	 * Returns an iterator for the first property of this node.
621 	 * Factory method for constructing a new node.  Attempts to parse a
622 	 * node in DTS format from the input, and returns it on success.  On
634 	 * Factory method for constructing a new node.  Attempts to parse a
635 	 * node in DTB format from the input, and returns it on success.  On
642 	 * Construct a new special node from a name and set of properties.
648 	 * node does not contain a property of that name.
652 	 * Adds a new property to this node.
659 	 * Adds a new child to this node.
666 	 * Deletes any children from this node.
673 	 * Merges a node into this one.  Any properties present in both are
678 	 * Write this node to the specified output.  Although nodes do not
681 	 * properties within this node and its children.
685 	 * Writes the current node as DTS to the specified file.  The second
691 	 * Recursively visit this node and then its children based on the
694 	 * not recurse into the current node's children, or VISIT_RECURSE to recurse
697 	visit_behavior visit(std::function<visit_behavior(node&, node*)>, node *parent);
709 	 * Type used for node paths.  A node path is sequence of names and unit
744 	 * set to true if a node marked /omit-if-no-ref/ is encountered.
759 	 * Root node.  All other nodes are children of this node.
764 	 * duplicate names are stored as (node*)-1.
766 	std::unordered_map<std::string, node*> node_names;
768 	 * A map from labels to node paths.  When resolving cross references,
790 		 * The path to the node.
832 	std::unordered_map<uint32_t, node*> used_phandles;
871 	 * Assign a phandle property to a single node.  The next parameter
875 	property_ptr assign_phandle(node *n, uint32_t &next);
879 	 * the node that it is passed.
883 	 * Calls the recursive version of this method on every root node.
888 	 * node must have their values replaced by either the node path or
921 	 * Should we write the __symbols__ node (to allow overlays to be linked
926 	 * Returns the node referenced by the property.  If this is a tree that
930 	node *referenced_node(property_value &v);
955 	 * Construct a fragment wrapper around node.  This will assume that node's
957 	 * be wrapped in an __overlay__ node.  The fragment wrapper will be assigned
960 	node_ptr create_fragment_wrapper(node_ptr &node, int &fragnum);
962 	 * Generate a root node from the node passed in.  This is sensitive to
968 	node_ptr generate_root(node_ptr &node, int &fragnum);
970 	 * Reassign any fragment numbers from this new node, based on the given
973 	void reassign_fragment_numbers(node_ptr &node, int &delta);
988 	 * node has been encountered.
1002 	 * Returns a pointer to the root node of this tree.  No ownership