2 * SPDX-License-Identifier: BSD-2-Clause
4 * Copyright (c) 2013 David Chisnall
7 * This software was developed by SRI International and the University of
8 * Cambridge Computer Laboratory under DARPA/AFRL contract (FA8750-10-C-0237)
9 * ("CTSRD"), as part of the DARPA CRASH research programme.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36 #include <unordered_map>
37 #include <unordered_set>
43 #include "input_buffer.hh"
60 * Type for device tree write functions.
62 typedef void (device_tree::* tree_write_fn_ptr)(int);
64 * Type for device tree read functions.
66 typedef void (device_tree::* tree_read_fn_ptr)(const std::string &, FILE *);
68 * Type for (owned) pointers to properties.
70 typedef std::shared_ptr<property> property_ptr;
72 * Owning pointer to a node.
74 typedef std::shared_ptr<node> node_ptr;
76 * Map from macros to property pointers.
78 typedef std::unordered_map<std::string, property_ptr> define_map;
80 * Set of strings used for label names.
82 typedef std::unordered_set<std::string> string_set;
84 * Properties may contain a number of different value, each with a different
85 * label. This class encapsulates a single value.
90 * The label for this data. This is usually empty.
94 * If this value is a string, or something resolved from a string (a
95 * reference) then this contains the source string.
97 std::string string_data;
99 * The data that should be written to the final output.
101 byte_buffer byte_data;
103 * Enumeration describing the possible types of a value. Note that
104 * property-coded arrays will appear simply as binary (or possibly
105 * string, if they happen to be nul-terminated and printable), and must
106 * be checked separately.
111 * This is a list of strings. When read from source, string
112 * lists become one property value for each string, however
113 * when read from binary we have a single property value
114 * incorporating the entire text, with nul bytes separating the
119 * This property contains a single string.
123 * This is a binary value. Check the size of byte_data to
124 * determine how many bytes this contains.
127 /** This contains a short-form address that should be replaced
128 * by a fully-qualified version. This will only appear when
129 * the input is a device tree source. When parsed from a
130 * device tree blob, the cross reference will have already been
131 * resolved and the property value will be a string containing
132 * the full path of the target node. */
135 * This is a phandle reference. When parsed from source, the
136 * string_data will contain the node label for the target and,
137 * after cross references have been resolved, the binary data
138 * will contain a 32-bit integer that should match the phandle
139 * property of the target node.
143 * An empty property value. This will never appear on a real
144 * property value, it is used by checkers to indicate that no
145 * property values should exist for a property.
149 * The type of this property has not yet been determined.
154 * The type of this property.
158 * Returns true if this value is a cross reference, false otherwise.
160 inline bool is_cross_reference()
162 return is_type(CROSS_REFERENCE);
165 * Returns true if this value is a phandle reference, false otherwise.
167 inline bool is_phandle()
169 return is_type(PHANDLE);
172 * Returns true if this value is a string, false otherwise.
174 inline bool is_string()
176 return is_type(STRING);
179 * Returns true if this value is a string list (a nul-separated
180 * sequence of strings), false otherwise.
182 inline bool is_string_list()
184 return is_type(STRING_LIST);
187 * Returns true if this value is binary, false otherwise.
189 inline bool is_binary()
191 return is_type(BINARY);
194 * Returns this property value as a 32-bit integer. Returns 0 if this
195 * property value is not 32 bits long. The bytes in the property value
196 * are assumed to be in big-endian format, but the return value is in
197 * the host native endian.
199 uint32_t get_as_uint32();
201 * Default constructor, specifying the label of the value.
203 property_value(std::string l=std::string()) : label(l), type(UNKNOWN) {}
205 * Writes the data for this value into an output buffer.
207 void push_to_buffer(byte_buffer &buffer);
210 * Writes the property value to the standard output. This uses the
211 * following heuristics for deciding how to print the output:
213 * - If the value is nul-terminated and only contains printable
214 * characters, it is written as a string.
215 * - If it is a multiple of 4 bytes long, then it is printed as cells.
216 * - Otherwise, it is printed as a byte buffer.
218 void write_dts(FILE *file);
220 * Tries to merge adjacent property values, returns true if it succeeds and
223 bool try_to_merge(property_value &other);
225 * Returns the size (in bytes) of this property value.
230 * Returns whether the value is of the specified type. If the type of
231 * the value has not yet been determined, then this calculates it.
233 inline bool is_type(value_type v)
242 * Determines the type of the value based on its contents.
246 * Writes the property value to the specified file as a quoted string.
247 * This is used when generating DTS.
249 void write_as_string(FILE *file);
251 * Writes the property value to the specified file as a sequence of
252 * 32-bit big-endian cells. This is used when generating DTS.
254 void write_as_cells(FILE *file);
256 * Writes the property value to the specified file as a sequence of
257 * bytes. This is used when generating DTS.
259 void write_as_bytes(FILE *file);
263 * A value encapsulating a single property. This contains a key, optionally a
264 * label, and optionally one or more values.
269 * The name of this property.
273 * Zero or more labels.
277 * The values in this property.
279 std::vector<property_value> values;
281 * Value indicating that this is a valid property. If a parse error
282 * occurs, then this value is false.
286 * Parses a string property value, i.e. a value enclosed in double quotes.
288 void parse_string(text_input_buffer &input);
290 * Parses one or more 32-bit values enclosed in angle brackets.
292 void parse_cells(text_input_buffer &input, int cell_size);
294 * Parses an array of bytes, contained within square brackets.
296 void parse_bytes(text_input_buffer &input);
298 * Parses a reference. This is a node label preceded by an ampersand
299 * symbol, which should expand to the full path to that node.
301 * Note: The specification says that the target of such a reference is
302 * a node name, however dtc assumes that it is a label, and so we
303 * follow their interpretation for compatibility.
305 void parse_reference(text_input_buffer &input);
307 * Parse a predefined macro definition for a property.
309 void parse_define(text_input_buffer &input, define_map *defines);
311 * Constructs a new property from two input buffers, pointing to the
312 * struct and strings tables in the device tree blob, respectively.
313 * The structs input buffer is assumed to have just consumed the
316 property(input_buffer &structs, input_buffer &strings);
318 * Parses a new property from the input buffer.
320 property(text_input_buffer &input,
324 define_map *defines);
327 * Creates an empty property.
329 property(std::string &&k, string_set &&l=string_set())
330 : key(k), labels(l), valid(true) {}
334 property(property &p) : key(p.key), labels(p.labels), values(p.values),
337 * Factory method for constructing a new property. Attempts to parse a
338 * property from the input, and returns it on success. On any parse
339 * error, this will return 0.
341 static property_ptr parse_dtb(input_buffer &structs,
342 input_buffer &strings);
344 * Factory method for constructing a new property. Attempts to parse a
345 * property from the input, and returns it on success. On any parse
346 * error, this will return 0.
348 static property_ptr parse(text_input_buffer &input,
350 string_set &&labels=string_set(),
351 bool semicolonTerminated=true,
352 define_map *defines=0);
354 * Iterator type used for accessing the values of a property.
356 typedef std::vector<property_value>::iterator value_iterator;
358 * Returns an iterator referring to the first value in this property.
360 inline value_iterator begin()
362 return values.begin();
365 * Returns an iterator referring to the last value in this property.
367 inline value_iterator end()
372 * Adds a new value to an existing property.
374 inline void add_value(property_value v)
379 * Returns the key for this property.
381 inline const std::string &get_key()
386 * Writes the property to the specified writer. The property name is a
387 * reference into the strings table.
389 void write(dtb::output_writer &writer, dtb::string_table &strings);
391 * Writes in DTS format to the specified file, at the given indent
392 * level. This will begin the line with the number of tabs specified
393 * as the indent level and then write the property in the most
394 * applicable way that it can determine.
396 void write_dts(FILE *file, int indent);
398 * Returns the byte offset of the specified property value.
400 size_t offset_of_value(property_value &val);
404 * Class encapsulating a device tree node. Nodes may contain properties and
411 * The labels for this node, if any. Node labels are used as the
412 * targets for cross references.
414 std::unordered_set<std::string> labels;
416 * The name of the node.
420 * The name of the node is a path reference.
422 bool name_is_path_reference = false;
424 * The unit address of the node, which is optionally written after the
425 * name followed by an at symbol.
427 std::string unit_address;
429 * A flag indicating that this node has been marked /omit-if-no-ref/ and
430 * will be omitted if it is not referenced, either directly or indirectly,
431 * by a node that is not similarly denoted.
433 bool omit_if_no_ref = false;
435 * A flag indicating that this node has been referenced, either directly
436 * or indirectly, by a node that is not marked /omit-if-no-ref/.
440 * The type for the property vector.
442 typedef std::vector<property_ptr> property_vector;
444 * Iterator type for child nodes.
446 typedef std::vector<node_ptr>::iterator child_iterator;
448 * Recursion behavior to be observed for visiting
453 * Recurse as normal through the rest of the tree.
457 * Continue recursing through the device tree, but do not
458 * recurse through this branch of the tree any further.
462 * Immediately halt the visit. No further nodes will be visited.
468 * Adaptor to use children in range-based for loops.
472 child_range(node &nd) : n(nd) {}
473 child_iterator begin() { return n.child_begin(); }
474 child_iterator end() { return n.child_end(); }
479 * Adaptor to use properties in range-based for loops.
481 struct property_range
483 property_range(node &nd) : n(nd) {}
484 property_vector::iterator begin() { return n.property_begin(); }
485 property_vector::iterator end() { return n.property_end(); }
490 * The properties contained within this node.
492 property_vector props;
494 * The children of this node.
496 std::vector<node_ptr> children;
498 * Children that should be deleted from this node when merging.
500 std::unordered_set<std::string> deleted_children;
502 * Properties that should be deleted from this node when merging.
504 std::unordered_set<std::string> deleted_props;
506 * A flag indicating whether this node is valid. This is set to false
507 * if an error occurs during parsing.
511 * Parses a name inside a node, writing the string passed as the last
512 * argument as an error if it fails.
514 std::string parse_name(text_input_buffer &input,
518 * Constructs a new node from two input buffers, pointing to the struct
519 * and strings tables in the device tree blob, respectively.
521 node(input_buffer &structs, input_buffer &strings);
523 * Parses a new node from the specified input buffer. This is called
524 * when the input cursor is on the open brace for the start of the
525 * node. The name, and optionally label and unit address, should have
526 * already been parsed.
528 node(text_input_buffer &input,
531 std::unordered_set<std::string> &&l,
535 * Creates a special node with the specified name and properties.
537 node(const std::string &n, const std::vector<property_ptr> &p);
539 * Comparison function for properties, used when sorting the properties
540 * vector. Orders the properties based on their names.
542 static inline bool cmp_properties(property_ptr &p1, property_ptr &p2);
545 return p1->get_key() < p2->get_key();
549 * Comparison function for nodes, used when sorting the children
550 * vector. Orders the nodes based on their names or, if the names are
551 * the same, by the unit addresses.
553 static inline bool cmp_children(node_ptr &c1, node_ptr &c2);
556 * Sorts the node's properties and children into alphabetical order and
557 * recursively sorts the children.
561 * Returns an iterator for the first child of this node.
563 inline child_iterator child_begin()
565 return children.begin();
568 * Returns an iterator after the last child of this node.
570 inline child_iterator child_end()
572 return children.end();
575 * Returns a range suitable for use in a range-based for loop describing
576 * the children of this node.
578 inline child_range child_nodes()
580 return child_range(*this);
583 * Accessor for the deleted children.
585 inline const std::unordered_set<std::string> &deleted_child_nodes()
587 return deleted_children;
590 * Accessor for the deleted properties
592 inline const std::unordered_set<std::string> &deleted_properties()
594 return deleted_props;
597 * Returns a range suitable for use in a range-based for loop describing
598 * the properties of this node.
600 inline property_range properties()
602 return property_range(*this);
605 * Returns an iterator after the last property of this node.
607 inline property_vector::iterator property_begin()
609 return props.begin();
612 * Returns an iterator for the first property of this node.
614 inline property_vector::iterator property_end()
619 * Factory method for constructing a new node. Attempts to parse a
620 * node in DTS format from the input, and returns it on success. On
621 * any parse error, this will return 0. This should be called with the
622 * cursor on the open brace of the property, after the name and so on
625 static node_ptr parse(text_input_buffer &input,
628 std::unordered_set<std::string> &&label=std::unordered_set<std::string>(),
629 std::string &&address=std::string(),
630 define_map *defines=0);
632 * Factory method for constructing a new node. Attempts to parse a
633 * node in DTB format from the input, and returns it on success. On
634 * any parse error, this will return 0. This should be called with the
635 * cursor on the open brace of the property, after the name and so on
638 static node_ptr parse_dtb(input_buffer &structs, input_buffer &strings);
640 * Construct a new special node from a name and set of properties.
642 static node_ptr create_special_node(const std::string &name,
643 const std::vector<property_ptr> &props);
645 * Returns a property corresponding to the specified key, or 0 if this
646 * node does not contain a property of that name.
648 property_ptr get_property(const std::string &key);
650 * Adds a new property to this node.
652 inline void add_property(property_ptr &p)
657 * Adds a new child to this node.
659 inline void add_child(node_ptr &&n)
661 children.push_back(std::move(n));
664 * Deletes any children from this node.
666 inline void delete_children_if(std::function<bool(node_ptr &)> predicate)
668 children.erase(std::remove_if(children.begin(), children.end(), predicate), children.end());
671 * Merges a node into this one. Any properties present in both are
672 * overridden, any properties present in only one are preserved.
674 void merge_node(node_ptr &other);
676 * Write this node to the specified output. Although nodes do not
677 * refer to a string table directly, their properties do. The string
678 * table passed as the second argument is used for the names of
679 * properties within this node and its children.
681 void write(dtb::output_writer &writer, dtb::string_table &strings);
683 * Writes the current node as DTS to the specified file. The second
684 * parameter is the indent level. This function will start every line
685 * with this number of tabs.
687 void write_dts(FILE *file, int indent);
689 * Recursively visit this node and then its children based on the
690 * callable's return value. The callable may return VISIT_BREAK
691 * immediately halt all recursion and end the visit, VISIT_CONTINUE to
692 * not recurse into the current node's children, or VISIT_RECURSE to recurse
693 * through children as expected. parent will be passed to the callable.
695 visit_behavior visit(std::function<visit_behavior(node&, node*)>, node *parent);
699 * Class encapsulating the entire parsed FDT. This is the top-level class,
700 * which parses the entire DTS representation and write out the finished
707 * Type used for node paths. A node path is sequence of names and unit
710 class node_path : public std::vector<std::pair<std::string,std::string>>
714 * Converts this to a string representation.
716 std::string to_string() const;
719 * Name that we should use for phandle nodes.
727 /** Create both nodes. */
732 * The format that we should use for writing phandles.
734 phandle_format phandle_node_name = EPAPR;
736 * Flag indicating that this tree is valid. This will be set to false
741 * Flag indicating that this tree requires garbage collection. This will be
742 * set to true if a node marked /omit-if-no-ref/ is encountered.
744 bool garbage_collect = false;
746 * Type used for memory reservations. A reservation is two 64-bit
747 * values indicating a base address and length in memory that the
748 * kernel should not use. The high 32 bits are ignored on 32-bit
751 typedef std::pair<uint64_t, uint64_t> reservation;
753 * The memory reserves table.
755 std::vector<reservation> reservations;
757 * Root node. All other nodes are children of this node.
761 * Mapping from names to nodes. Only unambiguous names are recorded,
762 * duplicate names are stored as (node*)-1.
764 std::unordered_map<std::string, node_ptr> node_names;
766 * Mapping from names to the nodes that contain them.
768 std::unordered_map<std::string, node_ptr> node_name_parents;
770 * A map from labels to node paths. When resolving cross references,
771 * we look up referenced nodes in this and replace the cross reference
772 * with the full path to its target.
774 std::unordered_map<std::string, node_path> node_paths;
776 * All of the elements in `node_paths` in the order that they were
777 * created. This is used for emitting the `__symbols__` section, where
778 * we want to guarantee stable ordering.
780 std::vector<std::pair<std::string, node_path>> ordered_node_paths;
782 * A collection of property values that are references to other nodes.
783 * These should be expanded to the full path of their targets.
785 std::vector<property_value*> cross_references;
787 * Labels collected from top-level /delete-node/ directives.
789 std::vector<std::string> deletions;
791 * The location of something requiring a fixup entry.
796 * The path to the node.
800 * The property containing the reference.
804 * The property value that contains the reference.
809 * A collection of property values that refer to phandles. These will
810 * be replaced by the value of the phandle property in their
813 std::vector<fixup> fixups;
815 * The locations of all of the values that are supposed to become phandle
816 * references, but refer to things outside of this file.
818 std::vector<std::reference_wrapper<fixup>> unresolved_fixups;
820 * The names of nodes that target phandles.
822 std::unordered_set<std::string> phandle_targets;
824 * A collection of input buffers that we are using. These input
825 * buffers are the ones that own their memory, and so we must preserve
826 * them for the lifetime of the device tree.
828 std::vector<std::unique_ptr<input_buffer>> buffers;
830 * A map of used phandle values to nodes. All phandles must be unique,
831 * so we keep a set of ones that the user explicitly provides in the
832 * input to ensure that we don't reuse them.
834 * This is a map, rather than a set, because we also want to be able to
835 * find phandles that were provided by the user explicitly when we are
838 std::unordered_map<uint32_t, node_ptr> used_phandles;
840 * Paths to search for include files. This contains a set of
841 * nul-terminated strings, which are not owned by this class and so
842 * must be freed separately.
844 std::vector<std::string> include_paths;
846 * Dictionary of predefined macros provided on the command line.
850 * The default boot CPU, specified in the device tree header.
852 uint32_t boot_cpu = 0;
854 * The number of empty reserve map entries to generate in the blob.
856 uint32_t spare_reserve_map_entries = 0;
858 * The minimum size in bytes of the blob.
860 uint32_t minimum_blob_size = 0;
862 * The number of bytes of padding to add to the end of the blob.
864 uint32_t blob_padding = 0;
866 * Is this tree a plugin?
868 bool is_plugin = false;
870 * Visit all of the nodes recursively, and if they have labels then add
871 * them to the node_paths and node_names vectors so that they can be
872 * used in resolving cross references. Also collects phandle
873 * properties that have been explicitly added.
875 void collect_names_recursive(node_ptr parent, node_ptr n, node_path &path);
877 * Assign a phandle property to a single node. The next parameter
878 * holds the phandle to be assigned, and will be incremented upon
881 property_ptr assign_phandle(node_ptr n, uint32_t &next);
883 * Assign phandle properties to all nodes that have been referenced and
884 * require one. This method will recursively visit the tree starting at
885 * the node that it is passed.
887 void assign_phandles(node_ptr n, uint32_t &next);
889 * Calls the recursive version of this method on every root node.
891 void collect_names();
893 * Resolves all cross references. Any properties that refer to another
894 * node must have their values replaced by either the node path or
895 * phandle value. The phandle parameter holds the next phandle to be
896 * assigned, should the need arise. It will be incremented upon each
897 * assignment of a phandle. Garbage collection of unreferenced nodes
898 * marked for "delete if unreferenced" will also occur here.
900 void resolve_cross_references(uint32_t &phandle);
902 * Garbage collects nodes that have been marked /omit-if-no-ref/ and do not
903 * have any references to them from nodes that are similarly marked. This
904 * is a fairly expensive operation. The return value indicates whether the
905 * tree has been dirtied as a result of this operation, so that the caller
906 * may take appropriate measures to bring the device tree into a consistent
909 bool garbage_collect_marked_nodes();
911 * Parses a dts file in the given buffer and adds the roots to the parsed
912 * set. The `read_header` argument indicates whether the header has
913 * already been read. Some dts files place the header in an include,
914 * rather than in the top-level file.
916 void parse_file(text_input_buffer &input,
917 std::vector<node_ptr> &roots,
920 * Template function that writes a dtb blob using the specified writer.
921 * The writer defines the output format (assembly, blob).
923 template<class writer>
927 * Should we write the __symbols__ node (to allow overlays to be linked
928 * against this blob)?
930 bool write_symbols = false;
932 * Returns the node referenced by the property. If this is a tree that
933 * is in source form, then we have a string that we can use to index
934 * the cross_references array and so we can just look that up.
936 node_ptr referenced_node(property_value &v);
938 * Writes this FDT as a DTB to the specified output.
940 void write_binary(int fd);
942 * Writes this FDT as an assembly representation of the DTB to the
943 * specified output. The result can then be assembled and linked into
946 void write_asm(int fd);
948 * Writes the tree in DTS (source) format.
950 void write_dts(int fd);
952 * Default constructor. Creates a valid, but empty FDT.
956 * Constructs a device tree from the specified file name, referring to
957 * a file that contains a device tree blob.
959 void parse_dtb(const std::string &fn, FILE *depfile);
961 * Construct a fragment wrapper around node. This will assume that node's
962 * name may be used as the target of the fragment, and the contents are to
963 * be wrapped in an __overlay__ node. The fragment wrapper will be assigned
964 * fragnumas its fragment number, and fragment number will be incremented.
966 node_ptr create_fragment_wrapper(node_ptr &node, int &fragnum);
968 * Generate a root node from the node passed in. This is sensitive to
969 * whether we're in a plugin context or not, so that if we're in a plugin we
970 * can circumvent any errors that might normally arise from a non-/ root.
971 * fragnum will be assigned to any fragment wrapper generated as a result
972 * of the call, and fragnum will be incremented.
974 node_ptr generate_root(node_ptr &node, int &fragnum);
976 * Reassign any fragment numbers from this new node, based on the given
979 void reassign_fragment_numbers(node_ptr &node, int &delta);
981 * Constructs a device tree from the specified file name, referring to
982 * a file that contains device tree source.
984 void parse_dts(const std::string &fn, FILE *depfile);
986 * Returns whether this tree is valid.
988 inline bool is_valid()
993 * Mark this tree as needing garbage collection, because an /omit-if-no-ref/
994 * node has been encountered.
996 void set_needs_garbage_collection()
998 garbage_collect = true;
1001 * Sets the format for writing phandle properties.
1003 inline void set_phandle_format(phandle_format f)
1005 phandle_node_name = f;
1008 * Returns a pointer to the root node of this tree. No ownership
1011 inline const node_ptr &get_root() const
1016 * Sets the physical boot CPU.
1018 void set_boot_cpu(uint32_t cpu)
1023 * Sorts the tree. Useful for debugging device trees.
1033 * Adds a path to search for include files. The argument must be a
1034 * nul-terminated string representing the path. The device tree keeps
1035 * a pointer to this string, but does not own it: the caller is
1036 * responsible for freeing it if required.
1038 void add_include_path(const char *path)
1040 std::string p(path);
1041 include_paths.push_back(std::move(p));
1044 * Sets the number of empty reserve map entries to add.
1046 void set_empty_reserve_map_entries(uint32_t e)
1048 spare_reserve_map_entries = e;
1051 * Sets the minimum size, in bytes, of the blob.
1053 void set_blob_minimum_size(uint32_t s)
1055 minimum_blob_size = s;
1058 * Sets the amount of padding to add to the blob.
1060 void set_blob_padding(uint32_t p)
1065 * Parses a predefined macro value.
1067 bool parse_define(const char *def);