cmdline/apt-sortpkgs.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: apt-sortpkgs.cc,v 1.5 2003/01/11 07:18:44 jgg Exp $
   4 /* ######################################################################
   5
   6    APT Sort Packages - Program to sort Package and Source files
   7
   8    This program is quite simple, it just sorts the package files by
   9    package and sorts the fields inside by the internal APT sort order.
  10    Input is taken from a named file and sent to stdout.
  11
  12    ##################################################################### */
  13                                                                         /*}}}*/
  14 // Include Files                                                        /*{{{*/
  15 #include <config.h>
  16
  17 #include <apt-pkg/tagfile.h>
  18 #include <apt-pkg/error.h>
  19 #include <apt-pkg/configuration.h>
  20 #include <apt-pkg/cmndline.h>
  21 #include <apt-pkg/init.h>
  22 #include <apt-pkg/strutl.h>
  23 #include <apt-pkg/fileutl.h>
  24 #include <apt-pkg/pkgsystem.h>
  25
  26 #include <apt-private/private-cmndline.h>
  27
  28 #include <vector>
  29 #include <algorithm>
  30 #include <stdio.h>
  31 #include <iostream>
  32 #include <string>
  33
  34 #include <apti18n.h>
  35                                                                         /*}}}*/
  36
  37 using namespace std;
  38
  39 struct PkgName                                                          /*{{{*/
  40 {
  41    string Name;
  42    string Ver;
  43    string Arch;
  44    unsigned long Offset;
  45    unsigned long Length;
  46
  47    inline int Compare3(const PkgName &x) const
  48    {
  49       int A = stringcasecmp(Name,x.Name);
  50       if (A == 0)
  51       {
  52          A = stringcasecmp(Ver,x.Ver);
  53          if (A == 0)
  54             A = stringcasecmp(Arch,x.Arch);
  55       }
  56       return A;
  57    }
  58
  59    bool operator <(const PkgName &x) const {return Compare3(x) < 0;};
  60    bool operator >(const PkgName &x) const {return Compare3(x) > 0;};
  61    bool operator ==(const PkgName &x) const {return Compare3(x) == 0;};
  62 };
  63                                                                         /*}}}*/
  64 // DoIt - Sort a single file                                            /*{{{*/
  65 // ---------------------------------------------------------------------
  66 /* */
  67 static bool DoIt(string InFile)
  68 {
  69    FileFd Fd(InFile,FileFd::ReadOnly);
  70    pkgTagFile Tags(&Fd);
  71    if (_error->PendingError() == true)
  72       return false;
  73
  74    // Parse.
  75    vector<PkgName> List;
  76    pkgTagSection Section;
  77    unsigned long Largest = 0;
  78    unsigned long Offset = Tags.Offset();
  79    bool Source = _config->FindB("APT::SortPkgs::Source",false);
  80    while (Tags.Step(Section) == true)
  81    {
  82       PkgName Tmp;
  83
  84       /* Fetch the name, auto-detecting if this is a source file or a
  85          package file */
  86       Tmp.Name = Section.FindS("Package");
  87       Tmp.Ver = Section.FindS("Version");
  88       Tmp.Arch = Section.FindS("Architecture");
  89
  90       if (Tmp.Name.empty() == true)
  91          return _error->Error(_("Unknown package record!"));
  92
  93       Tmp.Offset = Offset;
  94       Tmp.Length = Section.size();
  95       if (Largest < Tmp.Length)
  96          Largest = Tmp.Length;
  97
  98       List.push_back(Tmp);
  99
 100       Offset = Tags.Offset();
 101    }
 102    if (_error->PendingError() == true)
 103       return false;
 104
 105    // Sort it
 106    sort(List.begin(),List.end());
 107
 108    const char **Order = TFRewritePackageOrder;
 109    if (Source == true)
 110       Order = TFRewriteSourceOrder;
 111
 112    // Emit
 113    FileFd stdoutfd;
 114    stdoutfd.OpenDescriptor(STDOUT_FILENO, FileFd::WriteOnly, false);
 115    unsigned char *Buffer = new unsigned char[Largest+1];
 116    for (vector<PkgName>::iterator I = List.begin(); I != List.end(); ++I)
 117    {
 118       // Read in the Record.
 119       if (Fd.Seek(I->Offset) == false || Fd.Read(Buffer,I->Length) == false)
 120       {
 121          delete [] Buffer;
 122          return false;
 123       }
 124
 125       Buffer[I->Length] = '\n';
 126       if (Section.Scan((char *)Buffer,I->Length+1) == false)
 127       {
 128          delete [] Buffer;
 129          return _error->Error("Internal error, failed to scan buffer");
 130       }
 131
 132       // Sort the section
 133       if (Section.Write(stdoutfd, Order) == false || stdoutfd.Write("\n", 1) == false)
 134       {
 135          delete [] Buffer;
 136          return _error->Error("Internal error, failed to sort fields");
 137       }
 138    }
 139
 140    delete [] Buffer;
 141    return true;
 142 }
 143                                                                         /*}}}*/
 144 // ShowHelp - Show the help text                                        /*{{{*/
 145 // ---------------------------------------------------------------------
 146 /* */
 147 static bool ShowHelp(CommandLine &)
 148 {
 149    ioprintf(std::cout, "%s %s (%s)\n", PACKAGE, PACKAGE_VERSION, COMMON_ARCH);
 150    if (_config->FindB("version") == true)
 151       return true;
 152
 153    cout <<
 154     _("Usage: apt-sortpkgs [options] file1 [file2 ...]\n"
 155       "\n"
 156       "apt-sortpkgs is a simple tool to sort package files. The -s option is used\n"
 157       "to indicate what kind of file it is.\n"
 158       "\n"
 159       "Options:\n"
 160       "  -h   This help text\n"
 161       "  -s   Use source file sorting\n"
 162       "  -c=? Read this configuration file\n"
 163       "  -o=? Set an arbitrary configuration option, eg -o dir::cache=/tmp\n");
 164
 165    return true;
 166 }
 167                                                                         /*}}}*/
 168 int main(int argc,const char *argv[])                                   /*{{{*/
 169 {
 170    CommandLine::Args Args[] = {
 171       {'h',"help","help",0},
 172       {'v',"version","version",0},
 173       {'s',"source","APT::SortPkgs::Source",0},
 174       {'c',"config-file",0,CommandLine::ConfigFile},
 175       {'o',"option",0,CommandLine::ArbItem},
 176       {0,0,0,0}};
 177
 178    // Set up gettext support
 179    setlocale(LC_ALL,"");
 180    textdomain(PACKAGE);
 181
 182    // Parse the command line and initialize the package library
 183    CommandLine::Dispatch Cmds[] = {{NULL, NULL}};
 184    CommandLine CmdL;
 185    ParseCommandLine(CmdL, Cmds, Args, &_config, &_system, argc, argv, ShowHelp);
 186
 187    // Match the operation
 188    for (unsigned int I = 0; I != CmdL.FileSize(); I++)
 189       if (DoIt(CmdL.FileList[I]) == false)
 190          break;
 191
 192    // Print any errors or warnings found during parsing
 193    if (_error->empty() == false)
 194    {
 195       bool Errors = _error->PendingError();
 196       _error->DumpErrors();
 197       return Errors == true?100:0;
 198    }
 199
 200    return 0;
 201 }
 202                                                                         /*}}}*/