GNU.WIKI: The GNU/Linux Knowledge Base

  [HOME] [PHP Manual] [HowTo] [ABS] [MAN1] [MAN2] [MAN3] [MAN4] [MAN5] [MAN6] [MAN7] [MAN8] [MAN9]

  [0-9] [Aa] [Bb] [Cc] [Dd] [Ee] [Ff] [Gg] [Hh] [Ii] [Jj] [Kk] [Ll] [Mm] [Nn] [Oo] [Pp] [Qq] [Rr] [Ss] [Tt] [Uu] [Vv] [Ww] [Xx] [Yy] [Zz]


       xara - GTK2 interface for the above


   Graphical interface (GTK2):

       The graphical interface allows the user to input queries and browse the
       results.  Menu options are provided for  installing  and  removing  the
       selected  packages  using apt-get.  The packages the user is interested
       in may be bookmarked.

       Command-line interface (GTK2): A  command-line  interface,  ara(1),  is
       provided by the Debian package ara.

   Query syntax
       See  the  EXAMPLES  section  for  a  quick introduction ; xara has some
       built-in help.  The syntax is described in detail below.


       ara and xara allow the user  to  search  the  Debian  software  package
       database  (which  includes  installed  and  uninstalled packages) using
       powerful queries made of boolean combinations  of  regular  expressions
       acting on fields given by patterns.

       For  example, the query section=utils & depends:(gtk or tk8 or xlibs or
       kde or gnome or qt) & debian & package will  display  packages  in  the
       section  utils  that  have graphical interfaces (because they depend on
       graphical toolkits or X11 libraries), and  whose  description  contains
       the words debian and package.


       Debian  users  can easily install software with the commands dselect or
       apt-get install.  They can choose (on Debian 3.1  unstable)  from  over
       30,000  packages.   Finding  the  right package can be quite difficult.
       Although packages are categorized in crude sections,  there  are  still
       too many packages and reading all descriptions is out of the question.

       The  database files are huge and their mail-like syntax makes them hard
       to search with line-oriented tools like  grep.   There  exist  commands
       such  as  dpkg-iasearch(1)  or dpkg-dctrl(1) but their capabilities are
       limited.  Graphical  package  management  tools  such  as  aptitude  or
       synaptic  have  search  capabilities.   Although  ara  can  call apt to
       install or remove packages, its  orientation  is  that  of  a  powerful
       search  tool.   Indeed,  the name ara comes from the imperative form of
       the Turkish verb aramak which means "to search".


       The  database  of  Debian   packages   is   a   huge   text   file   at
       /var/lib/dpkg/available   (or   a   collection   of  text  files  under
       /var/lib/apt/lists/).  These files are in a mailbox-like format, and  a
       typical entry looks like this:

       Priority: required
       Section: base
       Installed-Size: 460
       Origin: debian
       Maintainer: Dpkg Development <>
       Bugs: debbugs://
       Architecture: i386
       Source: dpkg
       Version: 1.10.24
       Replaces: dpkg (<< 1.10.3)
       Depends: libc6 (>= 2.3.2.ds1-4), ....
       Filename: pool/main/d/dpkg/dselect_1.10.24_i386.deb
       Size: 119586
       MD5sum: c740f7f68dab08badf4f60b51a33500a
       Description: a user tool to manage Debian packages
        dselect is the primary user interface for installing, removing and
        managing Debian packages. It is a front-end to dpkg.

       Each package is thus described by a set of fields (like Package, Description, Version...).


       Here  we  describe the query syntax in some detail.  As of version 1.0,
       ara introduces new, simplified syntax which is  quite  traditional  and
       should  be familiar to anyone having used search engines.  Search terms
       are simply combined with AND, OR and NOT boolean operators.   Having  a
       look  at  the EXAMPLES section at the end of this manual should provide
       you a starting point.

       Consider the set D of Debian package descriptions contained in the file
       /var/lib/dpkg/available  (or in files under /var/lib/apt/lists/).  Each
       description is a set of couples of the form (f,v) where  f  and  v  are
       strings:  f  is  the  name  of the field (namely, Package, Description,
       Filename, Depends, etc.); v is its value.  Thus D is a set  of  set  of
       couples,  forming the universe.  Queries select subsets of the universe
       D.  Output options select which fields of  the  selected  part  of  the
       universe to display, and how to display them.

       A  query  is  a  boolean  combination of atomic expressions.  An atomic
       expression selects a subset of the set D of descriptions.  I call  this
       set  the  meaning of the expression; if e denotes an atomic expression,
       its meaning is denoted by [e].  The meaning of a boolean combination of
       atomic  expressions  is  just the boolean combination of the meaning of
       its constituents.  In other words, if e1 and e2 are atomic expressions,
       then  e1  &  e2  is  a  query, whose meaning is the intersection of the
       meanings of e1 and e2; and the meaning of e1 | e2 is the union  of  the
       meanings of e1 and e2.

   Atomic expressions
       Atomic   expressions   can   be   of   the   forms  pattern,  /regexp/,
       quoted_string,  fieldspec  operator1  string,  or  fieldspec  operator2

   Boolean operators and constants
       e1 & e2 (also e1 AND e2, e1 and e2)
              This  is  logical  conjunction  (set intersection).  Returns the
              intersection of [e1] and [e2], i.e. packages satisfying both  e1
              and e2.

       e1 | e2 (also e1 OR e2, e1 or e2)
              This  is  logical  disjunction  (set  union).  Union of [e1] and
              [e2], i.e. packages satisfying e1, e2 or both.

       !e1 (also NOT e1, not e1)
              This is logical negation (set complementation).   Complement  of
              [e1], i.e. packages not satisfying e1.

              Please  note  that  ~  stands  for  the  current  default  field
              specifier and is not an alias for the complementation operator.

       true (also all)
              The set of all descriptions, i.e. all packages.

       false (also none)
              The empty set, i.e. no packages.

   Field specifiers
       A  field  specifier  fieldspec  is  a  comma-separated  list  of  field

       Field patterns are like simple shell patterns and they may contain star
       characters (which stand for anything) or question  marks  (which  stand
       for  any single character).  They are case-insensitive.  They specify a
       set of fields.

       For example description and Description specify the  set  of  fields  {
       Description }, whereas de* specifies { Description, Depends }.

       The  special  specifier  ~  denotes  the current default specifier (see

   Current fields specifiers and simplified atomic expressions
       The need to repeat the  field  specifier  can  make  the  above  syntax
       cumbersome.   That  is  why  there  is  a current field specifier.  The
       current  field   specified   is,   by   default,   Description,Package.
       Simplified  atomic  expressions  are  simply  words or simplified shell
       expressions (which do not need to be enclosed  in  double  quotes)  and
       they  are  searched in fields in the current field specifier.  They can
       be made of letters, digits, underscores, dashes and periods.  They  may
       contain  stars  of  question  marks  which are interpreted as for field
       patterns (i.e., as simplified shell expressions).  If double quotes are
       used, other characters and spaces can be used.

       The  default  field  specifier  in  a  query  query  can  be changed to
       fieldspec by simply prefixing the query with  fieldspec:.   This  gives
       fieldspec:query.   However  if  query is complex (i.e., contains binary
       boolean operators) you need to enclose  query  in  parentheses,  as  in
       fieldspec:(query1 or query2).

   String literals
       String  literals  can  be  given with or without double quotes; without
       double quotes, the syntax is as for C identifiers, except that you  can
       use  dashes,  you must start with a latin letter ([a-zA-Z]) and you can
       continue   with   Latin   letters,   decimal   digits   or   underscore
       ([a-zA-Z0-9_]).   Inside  double  quotes,  all  characters are allowed,
       except double quotes, which must be preceded by a backslash.

       Results of queries can be stored in variables, which  may  be  recalled
       later.   This  isn't  very  useful  in  batch  mode  but  is  useful in
       interactive and graphical modes.

       Variable names start with a dollar and  follow  usual  conventions  for
       variables,  i.e.,  they  can  be any mix of alphanumeric characters and
       symbols such as underscore, dash, etc.

       Variable names are case-sensitive so that $Installed and $installed are

       To assign the result of a query (which is a set of packages) a variable
       named $variable just execute the query $variable  :=  query.   You  may
       then recall this particular set by simply writing $variable.

       Example: $installed := status:(installed & !not-installed)

       Hierarchical  comparison  operators  can  be  negated  by  changing the
       direction of the angle brackets and adding or removing an equality sign
       at  end  (<=  becomes  >).   Other  operators are negated as follows: =
       becomes != and =~ becomes !~.

              Atomic expression selecting packages having a field in fieldspec
              having a value a value exactly equal to string.

       fieldspec<string          (fieldspec<=string,         fieldspec>string,
              Atomic expression selecting packages having a field in fieldspec
              whose value is strictly less than string.  The order used is the
              Debian versioning order.  This  order  is  compatible  with  the
              natural order on integers and with Debian version numbers.  When
              comparing strings not  containing  special  characters,  letters
              sort  before numbers, as opposed to lexicographic ASCII order we
              are used to.  This means that hexadecimal numbers (such  as  MD5
              sums) will not have their usual order.

              Note  that  string  must  be  on  the right side of the operator
              (i.e., you cannot write 1000 < Size).

       fieldspec=~/expression/ (also fieldspec:/expression/)
              Selects descriptions whose  field  named  fieldspec  exists  and
              whose  value  matches,  case-sensitively, the regular expression

       fieldspec=~/expression/i (also fieldspec:/expression/i)
              Same as above, but the regular expression is case-insensitive.

       fieldspec=~/expression/w (also fieldspec:/expression/w)
              Same as above, but the regular expression is case-sensitive  and
              matches  only at word boundaries.  Note that letters-to-digit or
              digit-to-letter  transitions   are   considered   to   be   word

       fieldspec=~/expression/iw (also fieldspec:/expression/iw)
              The  regular  expression here is case-insensitive and matched at
              word boundaries.

   Regular expressions
       Regular expressions are given between a pair of slashes; the last slash
       can  be  followed  by a commutative sequence of letters denoting flags.
       Regular  expression  syntax  is  sed-like:  grouping  parentheses   and
       alternation  must  be backslashed.  For more details, see the Objective
       Caml  manual  chapter  on  the  Str  module.   In  short  (x,x1,x2  are
       meta-symbols denoting regular expressions):

       /./    Any character.

       /toto/ Literal string toto.

       /x1x2/ Concatenation.


              Star closure.

       [c-d]  Character range.

       \b     Word boundaries.

       /x/i   Case insensitive.

       /x/w   At word boundaries.

       Most   queries   will   contain   an   appreciable   amount   of  shell
       metacharacters.  For example, logical disjunction  is  denoted  by  the
       pipe  character,  which  is  used  by all known shells.  The problem is
       aggravated by the fact that names of real commands are likely to appear
       in  the  used  expressions;  successfully setting up a UNIX pipeline by
       error is therefore plausible.

       When calling ara from the command line in batch mode, You are  strongly
       urged  to  protect your queries by surrounding them with simple quotes;
       never write something like ara  Pack*=~/halt|reboot|shutdown/  as  this
       will   very  likely  reboot  your  system  (and  is  incorrect  regular
       expression syntax, if halt or reboot or shutdown is meant:  pipes  must
       be     backslashed).      Instead,     one     should     write     ara
       'Pack*=~/halt\|reboot\|shutdown /'




              List the name of every package in section utils.

       Section=utils and !Depends:(gnome|kde|gtk)
               ... except those whose  dependency  field  matches  the  regexp

       Section=utils and Status:(installed & !not-installed)
              List all installed packages in section utils.

       section=utils and !depends:(gtk|gnome|kde) and priority=optional
               ... show only optional packages.

       section=utils    &    (!depends:(gtk|gnome|kde)    |   size<100000)   &
              Well, exclude gtk,gnome or kde stuff only  if  100000  bytes  or

       Section=games and not (Depends:(gtk|sdl|kde|opengl|gnome|qt)
                  or /shoot\|kill\|destroy\|blast\|race\|bomb/iw
                  or /multi\(-\|\)player\|strategy\|conquest\|3\(-\|\)d/iw)
                  and Depends:(xlibs or vga)
                  and Size <= 1000000

       Display all packages in the games section whose size does not exceeding
       one million bytes, and which do not depend on  fancy  stuff  like  GTK,
       SDL, KDE, OpenGL, Qt or Gnome, do not mention some form of violence (to
       shoot, to kill, etc.)  in  their  description,  are  not  described  as
       multi-player,  strategy,  conquest or three-dimensional, and yet depend
       on either xlibs or svga to exclude console-based games.


       xara reads the whole database into memory and then  processes  queries.
       Since  the  database  is  usually  big,  this takes some time. However,
       queries then run quite fast. So specify multiple  queries  or  use  the
       -interactive option to amortize the cost of reading the database.


       xara  is  released  under  the GNU General Public License, version 2, a
       copy of which is included in the source distribution.


       Many thanks to George Danchev, Thomas Schoepf and Sven Luther for doing
       the Debian packaging of ara and many helpful comments.


       The  system-wide  configuration file for xara is /etc/xara.config.  Its
       syntax is self-evident and follows the Ocaml lexical conventions.

       Values in the user-specific configuration  file  $HOME/.ara/xara.config
       override those of /etc/xara.config.

       The  user configuration file can be edited from the Configure menu item
       in the Settings menu.  GUI parameters such as window sizes and checkbox
       states are saved at exit in that file.


       Bookmarks are saved into $HOME/.ara/bookmarks.  $HOME/.ara/bookmarks

       The following databases are loaded by default:



       ara(1),     apt-cache(8),     aptitude(8),     dpkg(8),     dselect(8),
       grep-aptavail(1),  grep-available(1),  grep-dctrl(1),   grep-status(1),
       grep-dctrl(1), packagesearch(1), synaptic(1).


       Oguz            Berke           Durak           <>

                               November 1, 2004                        XARA(1)

  All copyrights belong to their respective owners. Other content (c) 2014-2018, GNU.WIKI. Please report site errors to
Page load time: 0.124 seconds. Last modified: November 04 2018 12:49:43.