content: [general]
  no_audit = true
  # it could also be an expression as long as `Meta.parse` can parse this string successfully.
  # basically, it should be the `expression` in the following code:
  # ccall((function_name, expression), returntype, (argtype1, ...), argvalue1, ...)
  library_name = "liblexbor"
  
  # this entry allows you to specify different library names for different headers.
  # in the following example:
  # library_names = {"config.h" = "libclang_config", "libclang_p.*.h" = "libclang_patch"}
  # those functions in the `config.h` will be generated as:
  # ccall((function_name, libclang_config), returntype, (argtype1, ...), argvalue1, ...)
  library_names = {}
  
  # output file path relative to the working directory
  output_file_path = "../src/liblexbor_api.jl"
  
  # if these are set, common file (types and constants) and API file (functions) will be separated
  # this is for compatibility, so prologue and epilogue are not supported.
  # output_api_file_path = "api.jl"
  # output_common_file_path = "common.jl"
  
  # if this entry is not empty, the generator will print the code below to the `output_file_path`.
  # module module_name
  #
  # end # module
  module_name = "LibLexbor"
  
  # if this entry is not empty, the generator will print the code below to the `output_file_path`.
  # using jll_pkg_name
  # export jll_pkg_name
  jll_pkg_name = "lexbor_jll"
  
  # for packages that have extra JLL package dependencies
  jll_pkg_extra = []
  
  # identifiers that starts with the string listed in this entry will be exported.
  export_symbol_prefixes = []
  
  # the code in the following file will be copy-pasted to `output_file_path` before the generated code.
  # this is often used for applying custom patches, e.g. adding missing definitions.
  prologue_file_path = "./prologue.jl"
  
  # the code in the following file will be copy-pasted to `output_file_path` after the generated code.
  # this is often used for applying custom patches.
  # epilogue_file_path = ""
  
  # node with an id in the `output_ignorelist` will be ignored in the printing passes.
  # this is very useful for custom editing.
  output_ignorelist = [
      "LEXBOR_VERSION_STRING",
      "LXB_HTML_VERSION_STRING",
      "LXB_CSS_VERSION_STRING",
      "LXB_CSS_SYNTAX_VERSION_STRING",
      "LXB_SELECTORS_VERSION_STRING",
      "LXB_CSS_SELECTORS_VERSION_STRING",
      "LXB_DOM_VERSION_STRING",
  ]
  
  # Julia's `@enum` do not allow duplicated values, so by default, C enums are translated to
  # CEnum.jl's `@cenum`.
  # if this entry is true, `@enum` is used and those duplicated enum constants are just commented.
  use_julia_native_enum_type = false
  
  # use `@cenum` but do not print `using CEnum`.
  # this is useful in the case of using `CEnum` directly in the source tree instead of using `CEnum` as a dependency
  print_using_CEnum = true
  
  # Print enums directly as integers without @(c)enum wrapper
  # Override above two options
  print_enum_as_integer = false
  
  # use deterministic symbol instead of `gensym`-generated `var"##XXX"`
  use_deterministic_symbol = true
  
  # by default, only those declarations in the local header file are processed.
  # those declarations in the system headers will be treated specially and will be generated if necessary.
  # if you'd like to generate all of the symbols in the system headers, please set this option to false.
  is_local_header_only = true
  
  # set this option to false if you'd like to ignore the symbols(even if necessary) in the system headers.
  generate_isystem_symbols = true
  
  # if this option is set to true, C code with a style of
  # ```c
  # typedef struct {
  #     int x;
  # } my_struct;
  # ```
  # will be generated as:
  # ```julia
  # struct my_struct
  #     x::Cint
  # end
  # ```
  # instead of
  # ```julia
  # struct var"##Ctag#NUM"
  #     x::Cint
  # end
  # const my_struct = var"##Ctag#NUM"
  # ```
  smart_de_anonymize = true
  
  # if set to true, static functions will be ignored
  skip_static_functions = false
  
  # EXPERIMENTAL
  # if this option is set to true, those structs that are not necessary to be an
  # immutable struct will be generated as a mutable struct.
  # this option is default to false, do read the paragraph below before using this feature.
  auto_mutability = false
  
  # add inner constructor `Foo() = new()`
  auto_mutability_with_new = true
  
  # if you feel like certain structs should not be generated as mutable struct, please add them in the following list.
  # for example, if a C function accepts a `Vector` of some type as its argument like:
  #     void foo(mutable_type *list, int n);
  # when calling this function via `ccall`, passing a `Vector{mutable_type}(undef, n)` to the first
  # argument will trigger a crash, the reason is mutable structs are not stored inline within a `Vector`,
  # one should use `Ref{NTuple{n,mutable_type}}()` instead.
  # this is not convenient and that's where the `auto_mutability_ignorelist` comes in.
  auto_mutability_ignorelist = []
  
  # opposite to `auto_mutability_ignorelist` and has a higher priority
  auto_mutability_includelist = []
  
  # if set to "raw", extract and dump raw c comment;
  # if set to "doxygen", parse and format doxygen comment.
  # note: by default, Clang only parses doxygen comment, pass `-fparse-all-comments` to Clang in order to parse non-doxygen comments.
  # extract_c_comment_style = "doxygen"
  
  # Pass a function to explicitly generate documentation. It will be called like
  # `callback_documentation(node::ExprNode, doc::Vector{String})` if it is
  # set. The `doc` argument will contain the docs parsed from the headers if
  # `extract_c_comment_style` is set, otherwise it will be an empty vector.
  #
  # Do *not* set this in the TOML file, it should be set in the generator script
  # to a function that takes in an ExprNode and returns a String[] (string
  # vector).
  # callback_documentation = ""
  
  # if set to true, single line comment will be printed as """comment""" instead of """\ncomment\n"""
  # fold_single_line_comment = false
  
  # if set to "outofline", documentation of struct fields will be collected at the "Fields" section of the struct
  # if set to "inline", documentation of struct fields will go right above struct definition
  # struct_field_comment_style = "outofline"
  
  # if set to "outofline", documentation of enumerators will be collected at the "Enumerators" section of the enum
  # enumerator_comment_style = "outofline"
  
  # if set to true, C function prototype will be included in documentation
  show_c_function_prototype = false
  
  [codegen]
  # map C's bool to Julia's Bool instead of `Cuchar` a.k.a `UInt8`.
  use_julia_bool = true
  
  # set this to true if the C routine always expects a NUL-terminated string.
  # TODO: support filtering
  always_NUL_terminated_string = true
  
  # generate strictly typed function
  is_function_strictly_typed = false
  
  # if true, opaque pointers in function arguments will be translated to `Ptr{Cvoid}`.
  opaque_func_arg_as_PtrCvoid = false
  
  # if true, opaque types are translated to `mutable struct` instead of `Cvoid`.
  opaque_as_mutable_struct = true
  
  # if true, use Julia 1.5's new `@ccall` macro
  use_ccall_macro = true
  
  # if true, variadic functions are wrapped with `@ccall` macro. Otherwise variadic functions are ignored.
  wrap_variadic_function = false
  
  # generate getproperty/setproperty! methods for the types in the following list
  field_access_method_list = []
  
  # the generator will prefix the function argument names in the following list with a "_" to
  # prevent the generated symbols from conflicting with the symbols defined and exported in Base.
  function_argument_conflict_symbols = []
  
  # emit constructors for all custom-layout structs like bitfield in the list,
  # or set to `true` to do so for all such structs
  add_record_constructors = false
  
  [codegen.macro]
  # it‘s highly recommended to set this entry to "basic".
  # if you'd like to skip all of the macros, please set this entry to "disable".
  # if you'd like to translate function-like macros to Julia, please set this entry to "aggressive".
  macro_mode = "disable"
  
  # function-like macros in the following list will always be translated.
  functionlike_macro_includelist = [
  ]
  
  # if true, the generator prints the following message as comments.
  # "# Skipping MacroDefinition: ..."
  add_comment_for_skipped_macro = true
  
  # if true, ignore any macros that is suffixed with "_H" or in the `ignore_header_guards_with_suffixes` list
  ignore_header_guards = true
  ignore_header_guards_with_suffixes = []
  
  # if true, ignore those pure definition macros in the C code
  ignore_pure_definition = true
  