Man Linux: Main Page and Category List


       Dpkg::Deps - parse and manipulate dependencies of Debian packages


       The Dpkg::Deps module provides objects implementing various types of

       The most important function is deps_parse(), it turns a dependency line
       in a set of Dpkg::Deps::{Simple,AND,OR,Union} objects depending on the


       All the deps_* functions are exported by default.

       deps_eval_implication($rel_p, $v_p, $rel_q, $v_q)
           ($rel_p, $v_p) and ($rel_q, $v_q) express two dependencies as
           (relation, version). The relation variable can have the following
           values that are exported by Dpkg::Version: REL_EQ, REL_LT, REL_LE,
           REL_GT, REL_GT.

           This functions returns 1 if the "p" dependency implies the "q"
           dependency. It returns 0 if the "p" dependency implies that "q" is
           not satisfied. It returns undef when there's no implication.

           The $v_p and $v_q parameter should be Dpkg::Version objects.

       my $dep = deps_parse($line, %options)
           This function parse the dependency line and returns an object,
           either a Dpkg::Deps::AND or a Dpkg::Deps::Union. Various options
           can alter the behaviour of that function.

           use_arch (defaults to 1)
               Take into account the architecture restriction part of the
               dependencies.  Set to 0 to completely ignore that information.

           host_arch (defaults to the current architecture)
               Define the host architecture. Needed only if the reduce_arch
               option is set to 1. By default it uses
               Dpkg::Arch::get_host_arch() to identify the proper

           reduce_arch (defaults to 0)
               If set to 1, ignore dependencies that do not concern the
               current host architecture. This implicitely strips off the
               architecture restriction list so that the resulting
               dependencies are directly applicable to the current

           union (defaults to 0)
               If set to 1, returns a Dpkg::Deps::Union instead of a
               Dpkg::Deps::AND. Use this when parsing non-dependency fields
               like Conflicts.

       deps_compare($a, $b)
           Implements a comparison operator between two dependency objects.
           This function is mainly used to implement the sort() method.

OBJECTS - Dpkg::Deps::*

       There are several kind of dependencies. A Dpkg::Deps::Simple dependency
       represents a single dependency statement (it relates to one package
       only).  Dpkg::Deps::Multiple dependencies are built on top of this
       object and combine several dependencies in a different manners.
       Dpkg::Deps::AND represents the logical "AND" between dependencies while
       Dpkg::Deps::OR represents the logical "OR". Dpkg::Deps::Multiple
       objects can contain Dpkg::Deps::Simple object as well as other
       Dpkg::Deps::Multiple objects.

       In practice, the code is only meant to handle the realistic cases
       which, given Debian's dependencies structure, imply those restrictions:
       AND can contain Simple or OR objects, OR can only contain Simple

       Dpkg::Deps::KnowFacts is a special object that is used while evaluating
       dependencies and while trying to simplify them. It represents a set of
       installed packages along with the virtual packages that they might

   Common functions
           Returns true if the dependency is empty and doesn't contain any
           useful information. This is true when a Dpkg::Deps::Simple object
           has not yet been initialized or when a (descendant of)
           Dpkg::Deps::Multiple contains an empty list of dependencies.

           Return a list of sub-dependencies. For Dpkg::Deps::Simple it
           returns itself.

           Return a string representing the dependency. If $fh is set, it
           prints the string to the filehandle.

           Returns 1 when $dep implies $other_dep. Returns 0 when $dep implies
           NOT($other_dep). Returns undef when there's no implication. $dep
           and $other_dep do not need to be of the same type.

           Sort alphabetically the internal list of dependencies. It's a no-op
           for Dpkg::Deps::Simple objects.

           Returns true if the dependency applies to the indicated
           architecture. For multiple dependencies, it returns true if at
           least one of the sub-dependencies apply to this architecture.

           Simplify the dependency to contain only information relevant to the
           given architecture. A Dpkg::Deps::Simple object can be left empty
           after this operation. For Dpkg::Deps::Multiple objects, the non-
           relevant sub-dependencies are simply removed.

           This trims off the architecture restriction list of
           Dpkg::Deps::Simple objects.

           Evaluates the dependency given a list of installed packages and a
           list of virtual packages provided. Those lists are part of the
           Dpkg::Deps::KnownFacts object given as parameters.

           Returns 1 when it's true, 0 when it's false, undef when some
           information is lacking to conclude.

       $dep->simplify_deps($facts, @assumed_deps)
           Simplify the dependency as much as possible given the list of facts
           (see object Dpkg::Deps::KnownFacts) and a list of other
           dependencies that we know to be true.

           For a simple dependency, returns the package name if the dependency
           applies only to a subset of architectures.  For multiple
           dependencies, it returns the list of package names that have such a

       Such an object has four interesting properties:

           The package name (can be undef if the dependency has not been
           initialized or if the simplification of the dependency lead to its

           The relational operator: "=", "<<", "<=", ">=" or ">>". It can be
           undefined if the dependency had no version restriction. In that
           case the following field is also undefined.

           The version.

           The list of architectures where this dependency is applicable. It's
           undefined when there's no restriction, otherwise it's an array ref.
           It can contain an exclusion list, in that case each architecture is
           prefixed with an exclamation mark.


       $simple_dep->parse_string("dpkg-dev (>= 1.14.8) [!hurd-i386]")
           Parse the dependency and modify internal properties to match the
           parsed dependency.

           Returns true if $simple_dep could be modified to represent the
           union of both dependencies. Otherwise returns false.

       This the base class for Dpkg::Deps::{AND,OR,Union}. It contains the

           Add a new dependency object at the end of the list.

       This object represents a list of dependencies who must be met at the
       same time.

           The output method uses ", " to join the list of sub-dependencies.

       This object represents a list of dependencies of which only one must be
       met for the dependency to be true.

           The output method uses " | " to join the list of sub-dependencies.

       This object represents a list of relationships.

           The output method uses ", " to join the list of relationships.

           Those methods are not meaningful for this object and always return

           The simplication is done to generate an union of all the
           relationships.  It uses $simple_dep->merge_union($other_dep) to get
           the its job done.

       This object represents a list of installed packages and a list of
       virtual packages provided (by the set of installed packages).

       my $facts = Dpkg::Deps::KnownFacts->new();
           Create a new object.

       $facts->add_installed_package($package, $version)
           Record that the given version of the package is installed. If
           $version is undefined we know that the package is installed but we
           don't know which version it is.

       $facts->add_provided_package($virtual, $relation, $version, $by)
           Record that the "$by" package provides the $virtual package.
           $relation and $version correspond to the associated relation given
           in the Provides field. This might be used in the future for
           versioned provides.

       my ($check, $param) = $facts->check_package($package)
           $check is one when the package is found. For a real package, $param
           contains the version. For a virtual package, $param contains an
           array reference containing the list of packages that provide it
           (each package is listed as [ $provider, $relation, $version ]).