• en

Module Debian

module Format822 : sig
val it : Common.Util.Info.t
val info : ('a, unit, string, unit) Pervasives.format4 -> 'a
val nt : Common.Util.Notice.t
val notice : ('a, unit, string, unit) Pervasives.format4 -> 'a
val wt : Common.Util.Warning.t
val warning : ('a, unit, string, unit) Pervasives.format4 -> 'a
val dt : Common.Util.Debug.t
val debug : ('a, unit, string, unit) Pervasives.format4 -> 'a
val fatal : ('a, unit, string, 'b) Pervasives.format4 -> 'a
type loc = (Lexing.position * Lexing.position)
type stanza = (string * (loc * string)) list
type doc = stanza list
val dummy_loc : loc
val extend_loc : ('a * 'b) -> ('c * 'd) -> ('a * 'd)
val loc_of_lexbuf : Lexing.lexbuf -> (Lexing.position * Lexing.position)
val pp_posfname : Lexing.position -> string
val pp_lpos : Lexing.position -> string
exception Parse_error_822 of string * loc
exception Syntax_error of string * loc
exception Type_error of string
type deb_parser = {
lexbuf : Lexing.lexbuf;
fname : string;
}
val from_channel : IO.input -> deb_parser
val parser_wrapper_ch : IO.input -> deb_parser -> 'a -> 'a
val parse_from_ch : deb_parser -> 'a -> IO.input -> 'a
type name = string
type version = string
type architecture = string
type architectures = architecture list
type buildprofile = string
type vpkgname = (string * architecture option)
type multiarch = TODO: a
type source = (name * version option)
type relop = string
type constr = (relop * version)
type vpkg = (vpkgname * constr option)
type vpkglist = vpkg list
type vpkgformula = vpkg list list
type builddep = (vpkg * (bool * architecture) list * (bool * buildprofile) list)
type builddepslist = builddep list
type builddepsformula = builddep list list
type action =
| I
| R
type suite = string
type vpkgreq = (action option * vpkg * suite option)
TODO: functor:dose.3.2.2+opam/dose3/Debian.Format822.RawInput
end
module Format822_parser : sig
type token =
| FIELD of (string * (Format822.loc * string))
| CONT of (Format822.loc * string)
| BLANKLINE
| EOF
| PGPHEAD
val doc_822 : Lexing.lexbuf -> token -> Lexing.lexbuf -> Format822.doc
val stanza_822 : Lexing.lexbuf -> token -> Lexing.lexbuf -> Format822.stanza option
val doc_822_sign : Lexing.lexbuf -> token -> Lexing.lexbuf -> Format822.stanza option
end
module Format822_lexer : sig
val get_range : Lexing.lexbuf -> (Lexing.position * Lexing.position)
val raise_error : Lexing.lexbuf -> char -> 'a
val __ocaml_lex_tables : Lexing.lex_tables
val token_822 : Lexing.lexbuf -> Format822_parser.token
val __ocaml_lex_token_822_rec : Lexing.lexbuf -> int -> Format822_parser.token
val pgpsignature : Lexing.lexbuf -> Format822_parser.token
val __ocaml_lex_pgpsignature_rec : Lexing.lexbuf -> int -> Format822_parser.token
end
module Packages_parser : sig
type token =
| IDENT of string
| VIDENT of string
| STRING of string
| RELOP of string
| LBRACKET
| RBRACKET
| LPAREN
| RPAREN
| LT
| GT
| COMMA
| PIPE
| EQ
| BANG
| PLUS
| MINUS
| COLON
| SLASH
| EOL
val pkgname_top : Lexing.lexbuf -> token -> Lexing.lexbuf -> Format822.name
val version_top : Lexing.lexbuf -> token -> Lexing.lexbuf -> Format822.version
val archlist_top : Lexing.lexbuf -> token -> Lexing.lexbuf -> Format822.architecture list
val multiarch_top : Lexing.lexbuf -> token -> Lexing.lexbuf -> Format822.multiarch
val source_top : Lexing.lexbuf -> token -> Lexing.lexbuf -> Format822.source
val vpkgname_top : Lexing.lexbuf -> token -> Lexing.lexbuf -> Format822.vpkgname
val vpkg_top : Lexing.lexbuf -> token -> Lexing.lexbuf -> Format822.vpkg
val vpkglist_top : Lexing.lexbuf -> token -> Lexing.lexbuf -> Format822.vpkglist
val vpkgformula_top : Lexing.lexbuf -> token -> Lexing.lexbuf -> Format822.vpkgformula
val builddepsformula_top : Lexing.lexbuf -> token -> Lexing.lexbuf -> Format822.builddepsformula
val builddepslist_top : Lexing.lexbuf -> token -> Lexing.lexbuf -> Format822.builddepslist
val request_top : Lexing.lexbuf -> token -> Lexing.lexbuf -> Format822.vpkgreq
val requestlist_top : Lexing.lexbuf -> token -> Lexing.lexbuf -> Format822.vpkgreq list
end
module Packages_lexer : sig
val __ocaml_lex_tables : Lexing.lex_tables
val token_deb : Lexing.lexbuf -> Packages_parser.token
val __ocaml_lex_token_deb_rec : Lexing.lexbuf -> int -> Packages_parser.token
end
module Packages : sig
val it : Common.Util.Info.t
val info : ('a, unit, string, unit) Pervasives.format4 -> 'a
val nt : Common.Util.Notice.t
val notice : ('a, unit, string, unit) Pervasives.format4 -> 'a
val wt : Common.Util.Warning.t
val warning : ('a, unit, string, unit) Pervasives.format4 -> 'a
val dt : Common.Util.Debug.t
val debug : ('a, unit, string, unit) Pervasives.format4 -> 'a
val fatal : ('a, unit, string, 'b) Pervasives.format4 -> 'a
type package = {
name : Format822.name;
version : Format822.version;
architecture : Format822.architecture;
multiarch : Format822.multiarch;
essential : bool;
build_essential : bool;
extra_source_only : bool;
priority : string;
source : (Format822.name * Format822.version option);
depends : Format822.vpkgformula;
pre_depends : Format822.vpkgformula;
recommends : Format822.vpkgformula;
suggests : Format822.vpkgformula;
enhances : Format822.vpkgformula;
conflicts : Format822.vpkglist;
breaks : Format822.vpkglist;
replaces : Format822.vpkglist;
provides : Format822.vpkglist;
extras : (string * string) list;
}
debian package format
val default_package : package
val lexbuf_wrapper : Lexing.lexbuf -> Packages_parser.token -> Lexing.lexbuf -> 'a -> (Format822.loc * string) -> 'a
val parse_name : (Format822.loc * Format822.architecture) -> Format822.name
val parse_version : (Format822.loc * Format822.architecture) -> Format822.version
val parse_multiarch : (Format822.loc * Format822.architecture) -> Format822.multiarch
val parse_source : (Format822.loc * Format822.architecture) -> Format822.source
val parse_vpkg : (Format822.loc * string) -> Format822.vpkg
val parse_vpkglist : (Format822.loc * Format822.architecture) -> Format822.vpkglist
val parse_vpkgformula : (Format822.loc * Format822.architecture) -> Format822.vpkgformula
val parse_binarylist : (Format822.loc * string) -> Format822.vpkglist
val assoc : string -> (string * 'a) list -> 'a
exception ParseError of string * string
exception IgnorePackage of string
val parse_s : ?opt:'a -> ?err:string -> ?multi:bool -> ('b * 'c) -> 'a -> string -> (string * ('b * 'c)) list -> 'a
val parse_string : ('a * 'b) -> 'b
val parse_int : ('a * string) -> int
val parse_e : (string * (string * ('a * 'b)) list -> 'b option) list -> (string * ('a * 'b)) list -> (string * 'b) list
val parse_bool : ('a * string) -> bool
val parse_architecture : string list -> ('a * string) -> string
val parse_package_stanza : (string * (Format822.loc * Format822.architecture)) list -> bool option -> Format822.architecture list -> (string * (string * (Format822.loc * Format822.architecture)) list -> Format822.architecture option) list -> (string * (Format822.loc * Format822.architecture)) list -> package option
val status_filter : (string * ('a * string)) list -> bool
val arch_filter : 'a list -> (string * ('b * 'a)) list -> bool
val packages_parser : string -> (string * (Format822.loc * string)) list -> 'a option -> 'a list -> Format822.deb_parser -> 'a list
val parse_packages_in : ?filter:(string * (Format822.loc * Format822.architecture)) list -> bool -> ?archs:Format822.architecture list -> ?extras:(string * (string * (Format822.loc * Format822.architecture)) list -> Format822.architecture option) list -> string -> IO.input -> package list
val id : package -> (Format822.name * Format822.version * Format822.architecture)
val (>%) : package -> package -> int
module Set : sig
type elt = package
type t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : elt -> unit -> t -> unit
val fold : elt -> 'a -> 'a -> t -> 'a -> 'a
val for_all : elt -> bool -> t -> bool
val exists : elt -> bool -> t -> bool
val filter : elt -> bool -> t -> t
val partition : elt -> bool -> t -> (t * t)
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> (t * bool * t)
val find : elt -> t -> elt
val of_list : elt list -> t
end
val merge : Set.elt list -> Set.elt list -> Set.elt list
val installed_re : Re.re
val is_installed : package -> bool
val is_on_hold : package -> bool
val default_extras : (string * 'a option) list
val input_raw : ?filter:(string * (Format822.loc * Format822.architecture)) list -> bool -> ?archs:Format822.architecture list -> ?extras:(string * (string * (Format822.loc * Format822.architecture)) list -> Format822.architecture option) list -> string list -> Set.elt list
val input_raw_ch : ?filter:(string * (Format822.loc * Format822.architecture)) list -> bool -> ?archs:Format822.architecture list -> ?extras:(string * (string * (Format822.loc * Format822.architecture)) list -> Format822.architecture option) list -> IO.input -> Set.elt list
end
module Apt : sig
module Pcre = Re_pcre
val it : Common.Util.Info.t
val info : ('a, unit, string, unit) Pervasives.format4 -> 'a
val nt : Common.Util.Notice.t
val notice : ('a, unit, string, unit) Pervasives.format4 -> 'a
val wt : Common.Util.Warning.t
val warning : ('a, unit, string, unit) Pervasives.format4 -> 'a
val dt : Common.Util.Debug.t
val debug : ('a, unit, string, unit) Pervasives.format4 -> 'a
val fatal : ('a, unit, string, 'b) Pervasives.format4 -> 'a
val blank_regexp : Re.re
val parse_inst : Pervasives.in_channel -> ((string * string), unit) ExtLib.Hashtbl.t
val parse_inst_from_cmd : string -> ((string * string), unit) ExtLib.Hashtbl.t
val parse_inst_from_file : string -> ((string * string), unit) ExtLib.Hashtbl.t
val parse_popcon : string -> (int * string * int)
type apt_req =
| Install of Format822.vpkgreq list
| Remove of Format822.vpkgreq list
| Upgrade of Format822.suite option
| DistUpgrade of Format822.suite option
val parse_req : string -> Format822.vpkgreq
val parse_pkg_req : Format822.suite option -> string -> (Format822.action option * ((string * Format822.architecture option) * Format822.constr option) * Format822.suite option)
val parse_request_apt : string -> apt_req
val parse_request_aptitude : string -> apt_req
module Pref : sig
for details on the apt_preferences format : man apt_preferences
type pin_t =
| Release of (string * string) list
| Origin of string
| Version of string
type package_t =
| Package of string
| Star
type pin_priority_t = int
type apt_preferences = {
package : package_t;
pin : pin_t;
pin_priority : pin_priority_t;
}
end
val comma_regexp : Re.re
val eq_regexp : Re.re
val di_regexp : Re.re
val al_regexp : Re.re
val parse_pref_labels : string -> (string * string) list
val general_regexp : Re.re
val parse_pref_package : ('a * Format822.architecture) -> Pref.package_t
val pin_regexp : Re.re
val parse_pin : ('a * string) -> Pref.pin_t
val parse_preferences_stanza : (string * ('a * Format822.architecture)) list -> Pref.apt_preferences
val preferences_parser : Format822.stanza -> 'a -> 'a list -> Format822.deb_parser -> 'a list
val parse_preferences_in : IO.input -> Pref.apt_preferences list
end
module Architecture : sig
val src_matches_arch : string -> string -> bool
check whether a source architecture string matches a host architecture. The source architecture string may contain architecture wildcards ("linux-any", "any-i386"), or be "any" or "all". The host architecure is one that may be obtained by running "dpkg-architecture -qDEB_HOST_ARCH").
val read_triplettable : ?ttfile:string option -> ?ctfile:string option -> unit -> unit
fill the lookup table mapping debian architectures to debian triplets this function is called by src_matches_arch without supplying anything for the optional ttfile and ctfile arguments. If they are not None, then they can point to a file like /usr/share/dpkg/triplettable or /usr/share/dpkg/cputable respectively.
end
module Sources : sig
val it : Common.Util.Info.t
val info : ('a, unit, string, unit) Pervasives.format4 -> 'a
val nt : Common.Util.Notice.t
val notice : ('a, unit, string, unit) Pervasives.format4 -> 'a
val wt : Common.Util.Warning.t
val warning : ('a, unit, string, unit) Pervasives.format4 -> 'a
val dt : Common.Util.Debug.t
val debug : ('a, unit, string, unit) Pervasives.format4 -> 'a
val fatal : ('a, unit, string, 'b) Pervasives.format4 -> 'a
type source = {
name : Format822.name;
version : Format822.version;
architecture : Format822.architecture list;
binaries : string list;
build_depends : Format822.builddepsformula;
build_depends_indep : Format822.builddepsformula;
build_conflicts : Format822.builddepslist;
build_conflicts_indep : Format822.builddepslist;
}
val default_source : source
val parse_s : ?opt:'a -> ?err:string -> ?multi:bool -> ('b * 'c) -> 'a -> string -> (string * ('b * 'c)) list -> 'a
val parse_name : (Format822.loc * Format822.architecture) -> Format822.name
val parse_version : (Format822.loc * Format822.architecture) -> Format822.version
val parse_builddepslist : (Format822.loc * Format822.architecture) -> Format822.builddepslist
val parse_builddepsformula : (Format822.loc * Format822.architecture) -> Format822.builddepsformula
val parse_architectures : string list -> (Format822.loc * string) -> Format822.architecture list
val parse_package_stanza : (string * (Format822.loc * Format822.architecture)) list -> bool option -> string list -> (string * (Format822.loc * Format822.architecture)) list -> source option
val parse_sources_in : ?filter:(string * (Format822.loc * Format822.architecture)) list -> bool -> ?archs:string list -> string -> IO.input -> source list
val input_raw : ?filter:(string * (Format822.loc * Format822.architecture)) list -> bool -> ?archs:string list -> string list -> source list
val sep : string
val select : string -> 'a option -> ('b * (bool * string) list * (bool * 'a) list) -> 'b option
val sources2packages : ?profiles:bool -> ?noindep:bool -> ?src:Format822.buildprofile -> Format822.architecture -> Format822.architecture -> source list -> Packages.package list
val is_source : ?src:string -> Packages.package -> bool
exception MismatchSrc of Cudf.package list
exception NotfoundSrc
val get_src_package : Cudf.universe -> Cudf.package -> Cudf.package
val get_bin_packages : 'a Pervasives.ref Common.CudfAdd.Cudf_hashtbl.t -> Common.CudfAdd.Cudf_hashtbl.key -> 'a
val binset : 'a -> Common.CudfAdd.Cudf_set.elt list -> 'a list -> Common.CudfAdd.Cudf_set.t
end
module Version : sig
val equal : string -> string -> bool
Returns true iff the two strings define the same version. Hence, the result may be true even when the two string differ syntactically.
val compare : string -> string -> int
compare x y returns 0 if x is eqivalent to y, -1 if x is smaller than y, and 1 if x is greater than y. This is consistent with Pervasives.compare.
type version_analysis =
| Native of string * string * string (* epoch,upstream,binnmu *)
| NonNative of string * string * string * string (* epoch,upstream,revision,binnmu *)
result type of the analysis of a version string. The binNMU part, if present, has been removed from the upstream (if native version) or revision (if non-native vesion).
val decompose : string -> version_analysis
decompose a version string
val compose : version_analysis -> string
recompose a decomposed version string. For all v: equal(v,compose(decompose v)) = true. There may, however, be small syntactic differences between v and compose(decompose v)
val strip_epoch_binnmu : string -> string
return a version without its epoch and without its binNMU part
val split : string -> (string * string * string * string)
split the debian version into its components. (epoch,upstream,revision,binnmu) = split v v = epoch ^ ":" ^ upstream ^ "-" ^ revision ^ binnmu.
Deprecated decompose should be used instead.
val concat : (string * string * string * string) -> string
Deprecated recompose should be used instead.
val normalize : string -> string
chop the epoch and binnmu component from a version.
Deprecated strip_epoch_binnmu should be used instead.
end
module Debcudf : sig
type tables
abstract data type holding the conversion tables for the debcudf translation.
type extramap = (string * (string * Cudf_types.typedecl1)) list
type options = {
extras_opt : extramap;
native : string option; (* the native architecture *)
foreign : string list; (* list of foreign architectures *)
host : string option; (* the host architecture - cross compile *)
ignore_essential : bool;
}
val default_options : options
val init_tables : ?step:int -> ?versionlist:Format822.version list -> Packages.package list -> tables
initialize the version conversion tables
val clear : tables -> unit
return the cudf version associated to a tuple (name,version). return Not_found if there is not package or cudf version associated to the tuple (name,version)
val get_cudf_version : tables -> (Format822.name * Format822.version) -> int
val get_real_version : tables -> (Cudf_types.pkgname * Cudf_types.version) -> Format822.version
return the real version associated to a Cudf package
val tocudf : tables -> ?options:options -> ?inst:bool -> Packages.package -> Cudf.package
tocudf tbl p convert the a debian package representation to cudf.
  • Version and package name normalization.
  • Adding self conflicts.
  • Virtual package normalization.
  • Adding priority information if avaiblable.
  • Mapping APT request.
inst : set the Installed cudf field
val lltocudf : ?enc:bool -> tables -> Format822.vpkg list list -> Cudf_types.vpkgformula
convert a debian dependency list in a cudf constraints formula
val ltocudf : ?enc:bool -> tables -> Format822.vpkg list -> Cudf_types.vpkglist
convert a debian conflict list in a cudf constraints list
val preamble : Cudf.preamble
declare the Cudf preamble used by cudf. Namely, debcudf add :
  • a property named Number of type string containing the original debian version
  • a property named Source of type string
  • a property named Sourceversion of type string
val load_universe : ?options:options -> Packages.package list -> Cudf.universe
create a Cudf universe from a debian package representation list.
val load_list : ?options:options -> Packages.package list -> Cudf.package list
create a Cudf package list from a debian package representation list.
end
module Release : sig
type release = {
fname : string;
origin : string;
label : string;
suite : string;
version : string;
codename : string;
date : string;
architecture : string;
component : string;
notauto : bool;
autoup : bool;
description : string;
md5sums : (string * string * string) list;
sha1 : (string * string * string) list;
sha256 : (string * string * string) list;
}
The type for representing the contents of one release file
val parse_release_in : string -> IO.input -> release option
parse_release_in filename channel parses the contents of a release file of name filename from the input channel channel. Returns Some(c) when c is the contents of the release file read from the stream, or None when the stream contains only whitespace.
The release file may be signed, but in this case the validity of the signature is not checked!!
end
module Debutil : sig
val it : Common.Util.Info.t
val info : ('a, unit, string, unit) Pervasives.format4 -> 'a
val nt : Common.Util.Notice.t
val notice : ('a, unit, string, unit) Pervasives.format4 -> 'a
val wt : Common.Util.Warning.t
val warning : ('a, unit, string, unit) Pervasives.format4 -> 'a
val dt : Common.Util.Debug.t
val debug : ('a, unit, string, unit) Pervasives.format4 -> 'a
val fatal : ('a, unit, string, 'b) Pervasives.format4 -> 'a
val get_source : Packages.package -> (Format822.name * Format822.version)
val cluster : Packages.package list -> ((Format822.name * Format822.version), (string * string * Packages.package list) list) ExtLib.Hashtbl.t
val debvpkg : (string * string) -> ('a * 'b) -> ((string * string option) * (string * string) option) -> (string * (TODO: c * 'b) option)
end
module Evolution : sig
type range = TODO: a
val string_of_range : TODO: a -> string
val range : ?bottom:bool -> string list -> TODO: a list
val discriminant : ?bottom:bool -> ?highest:bool -> TODO: a -> 'b -> 'c -> string list -> 'b list -> ('a * 'a list) list
val add_unique : ('a, ('b, unit) ExtLib.Hashtbl.t) ExtLib.Hashtbl.t -> 'a -> 'b -> unit
val conj_iter : ('a, ((TODO: b * string) option, unit) ExtLib.Hashtbl.t) ExtLib.Hashtbl.t -> (('a * 'c) * (string * string) option) list -> unit
val cnf_iter : ('a, ((TODO: b * string) option, unit) ExtLib.Hashtbl.t) ExtLib.Hashtbl.t -> (('a * 'c) * (string * string) option) list list -> unit
val constraints : Packages.package list -> (string, (TODO: a * string) list) ExtLib.Hashtbl.t
val all_constraints : ('a, 'b list) ExtLib.Hashtbl.t -> 'a -> 'b list
val align : string -> TODO: a -> 'a
val all_versions : ('a * 'b) list -> 'b list
val migrate : Packages.package list -> TODO: a -> ((Packages.package * 'a) * 'a) list
val extract_epochs : string list -> string list
val add_normalize : string list -> string list
val add_epochs : string list -> string list -> string list
val all_ver_constr : (Format822.name, ('a * Format822.version) list) ExtLib.Hashtbl.t -> Packages.package list -> (Format822.version list * ('a * Format822.version) list)
end
module Edsp : sig
module Pcre = Re_pcre
val it : Common.Util.Info.t
val info : ('a, unit, string, unit) Pervasives.format4 -> 'a
val nt : Common.Util.Notice.t
val notice : ('a, unit, string, unit) Pervasives.format4 -> 'a
val wt : Common.Util.Warning.t
val warning : ('a, unit, string, unit) Pervasives.format4 -> 'a
val dt : Common.Util.Debug.t
val debug : ('a, unit, string, unit) Pervasives.format4 -> 'a
val fatal : ('a, unit, string, 'b) Pervasives.format4 -> 'a
type request = {
request : string;
install : Format822.vpkg list;
remove : Format822.vpkg list;
architecture : Format822.architecture option;
architectures : Format822.architectures;
autoremove : bool;
upgrade : bool;
distupgrade : bool;
strict_pin : bool;
preferences : string;
cmdline : string;
}
val default_request : request
val from_apt_request : Format822.architecture option -> request -> Apt.apt_req -> request
val parse_s : ?opt:'a -> ?err:string -> ?multi:bool -> ('b * 'c) -> 'a -> string -> (string * ('b * 'c)) list -> 'a
val parse_string : ('a * 'b) -> 'b
val parse_string_opt : ('a * string) -> string option
val parse_string_list : ('a * string) -> string list
val parse_int_s : ('a * string) -> string
val parse_req : (Format822.loc * string) -> Format822.vpkg list
val parse_edsp_version : ('a * string) -> string
val parse_request_stanza : (string * (Format822.loc * Format822.architecture)) list -> request
val parse_bool_s : ('a * string) -> string
val parse_installed : Format822.stanza -> string
val parse_hold : Format822.stanza -> string
val parse_apt_id : Format822.stanza -> Format822.architecture
val parse_apt_pin : Format822.stanza -> string
val parse_automatic : Format822.stanza -> string
val parse_candidate : Format822.stanza -> string
val parse_section : Format822.stanza -> Format822.architecture
val extras : (string * Format822.stanza -> Format822.architecture option) list
val packages_parser : ?request:bool -> (request * Packages.package list) -> Format822.deb_parser -> (request * Packages.package list)
val input_raw_ch : IO.input -> (request * Packages.package list)
val input_raw : string -> (request * Packages.package list)
val extras_tocudf : (string * (string * TODO: a)) list
val is_installed : Packages.package -> bool
val is_on_hold : Packages.package -> bool
val tocudf : Debcudf.tables -> ?options:Debcudf.options -> ?inst:bool -> Packages.package -> Cudf.package
val requesttocudf : Debcudf.tables -> Cudf.universe -> request -> Cudf.request
end
module Printer : sig
val pp_multiarch : Pervasives.out_channel -> TODO: a -> unit
val string_of_vpkg : ((string * string option) * (string * string) option) -> string
val pp_vpkg : Pervasives.out_channel -> ((string * string option) * (string * string) option) -> unit
val string_of_vpkglist : ((string * string option) * (string * string) option) list -> string
val pp_vpkglist : Pervasives.out_channel -> ((string * string option) * (string * string) option) list -> unit
val string_of_vpkgformula : ((string * string option) * (string * string) option) list list -> string
val pp_vpkgformula : Pervasives.out_channel -> ((string * string option) * (string * string) option) list list -> unit
val pp_package : Pervasives.out_channel -> Packages.package -> unit
val strinf_of_builddep : (((string * string option) * (string * string) option) * (bool * string) list * (bool * string) list) -> string
val string_of_builddepformula : (((string * string option) * (string * string) option) * (bool * string) list * (bool * string) list) list list -> string
val pp_builddepformula : Pervasives.out_channel -> (((string * string option) * (string * string) option) * (bool * string) list * (bool * string) list) list list -> unit
val string_of_builddeplist : (((string * string option) * (string * string) option) * (bool * string) list * (bool * string) list) list -> string
val pp_builddeplist : Pervasives.out_channel -> (((string * string option) * (string * string) option) * (bool * string) list * (bool * string) list) list -> unit
val pp_source : Pervasives.out_channel -> Sources.source -> unit
end