apt-pkg/deb/debsrcrecords.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: debsrcrecords.cc,v 1.6 2004/03/17 05:58:54 mdz Exp $
   4 /* ######################################################################
   5
   6    Debian Source Package Records - Parser implementation for Debian style
   7                                    source indexes
   8
   9    ##################################################################### */
  10                                                                         /*}}}*/
  11 // Include Files                                                        /*{{{*/
  12 #include <apt-pkg/deblistparser.h>
  13 #include <apt-pkg/debsrcrecords.h>
  14 #include <apt-pkg/error.h>
  15 #include <apt-pkg/strutl.h>
  16 #include <apt-pkg/configuration.h>
  17
  18 using std::max;
  19                                                                         /*}}}*/
  20
  21 // SrcRecordParser::Binaries - Return the binaries field                /*{{{*/
  22 // ---------------------------------------------------------------------
  23 /* This member parses the binaries field into a pair of class arrays and
  24    returns a list of strings representing all of the components of the
  25    binaries field. The returned array need not be freed and will be
  26    reused by the next Binaries function call. This function is commonly
  27    used during scanning to find the right package */
  28 const char **debSrcRecordParser::Binaries()
  29 {
  30    // This should use Start/Stop too, it is supposed to be efficient after all.
  31    string Bins = Sect.FindS("Binary");
  32    if (Bins.empty() == true || Bins.length() >= 102400)
  33       return 0;
  34
  35    if (Bins.length() >= BufSize)
  36    {
  37       delete [] Buffer;
  38       // allocate new size based on buffer (but never smaller than 4000)
  39       BufSize = max((unsigned int)4000, max((unsigned int)Bins.length()+1,2*BufSize));
  40       Buffer = new char[BufSize];
  41    }
  42
  43    strcpy(Buffer,Bins.c_str());
  44    if (TokSplitString(',',Buffer,StaticBinList,
  45                       sizeof(StaticBinList)/sizeof(StaticBinList[0])) == false)
  46       return 0;
  47
  48    return (const char **)StaticBinList;
  49 }
  50                                                                         /*}}}*/
  51 // SrcRecordParser::BuildDepends - Return the Build-Depends information /*{{{*/
  52 // ---------------------------------------------------------------------
  53 /* This member parses the build-depends information and returns a list of
  54    package/version records representing the build dependency. The returned
  55    array need not be freed and will be reused by the next call to this
  56    function */
  57 bool debSrcRecordParser::BuildDepends(vector<pkgSrcRecords::Parser::BuildDepRec> &BuildDeps,
  58                                         bool const &ArchOnly, bool const &StripMultiArch)
  59 {
  60    unsigned int I;
  61    const char *Start, *Stop;
  62    BuildDepRec rec;
  63    const char *fields[] = {"Build-Depends",
  64                            "Build-Depends-Indep",
  65                            "Build-Conflicts",
  66                            "Build-Conflicts-Indep"};
  67
  68    BuildDeps.clear();
  69
  70    for (I = 0; I < 4; I++)
  71    {
  72       if (ArchOnly && (I == 1 || I == 3))
  73          continue;
  74
  75       if (Sect.Find(fields[I], Start, Stop) == false)
  76          continue;
  77
  78       while (1)
  79       {
  80          Start = debListParser::ParseDepends(Start, Stop,
  81                      rec.Package,rec.Version,rec.Op,true, StripMultiArch);
  82
  83          if (Start == 0)
  84             return _error->Error("Problem parsing dependency: %s", fields[I]);
  85          rec.Type = I;
  86
  87          if (rec.Package != "")
  88             BuildDeps.push_back(rec);
  89
  90          if (Start == Stop)
  91             break;
  92       }
  93    }
  94
  95    return true;
  96 }
  97                                                                         /*}}}*/
  98 // SrcRecordParser::Files - Return a list of files for this source      /*{{{*/
  99 // ---------------------------------------------------------------------
 100 /* This parses the list of files and returns it, each file is required to have
 101    a complete source package */
 102 bool debSrcRecordParser::Files(vector<pkgSrcRecords::File> &List)
 103 {
 104    List.erase(List.begin(),List.end());
 105
 106    string Files = Sect.FindS("Files");
 107    if (Files.empty() == true)
 108       return false;
 109
 110    // Stash the / terminated directory prefix
 111    string Base = Sect.FindS("Directory");
 112    if (Base.empty() == false && Base[Base.length()-1] != '/')
 113       Base += '/';
 114
 115    // Iterate over the entire list grabbing each triplet
 116    const char *C = Files.c_str();
 117    while (*C != 0)
 118    {
 119       pkgSrcRecords::File F;
 120       string Size;
 121
 122       // Parse each of the elements
 123       if (ParseQuoteWord(C,F.MD5Hash) == false ||
 124           ParseQuoteWord(C,Size) == false ||
 125           ParseQuoteWord(C,F.Path) == false)
 126          return _error->Error("Error parsing file record");
 127
 128       // Parse the size and append the directory
 129       F.Size = atoi(Size.c_str());
 130       F.Path = Base + F.Path;
 131
 132       // Try to guess what sort of file it is we are getting.
 133       string::size_type Pos = F.Path.length()-1;
 134       while (1)
 135       {
 136          string::size_type Tmp = F.Path.rfind('.',Pos);
 137          if (Tmp == string::npos)
 138             break;
 139          if (F.Type == "tar") {
 140             // source v3 has extension 'debian.tar.*' instead of 'diff.*'
 141             if (string(F.Path, Tmp+1, Pos-Tmp) == "debian")
 142                F.Type = "diff";
 143             break;
 144          }
 145          F.Type = string(F.Path,Tmp+1,Pos-Tmp);
 146
 147          if (F.Type == "gz" || F.Type == "bz2" || F.Type == "lzma" || F.Type == "tar")
 148          {
 149             Pos = Tmp-1;
 150             continue;
 151          }
 152
 153          break;
 154       }
 155
 156       List.push_back(F);
 157    }
 158
 159    return true;
 160 }
 161                                                                         /*}}}*/
 162 // SrcRecordParser::~SrcRecordParser - Destructor                       /*{{{*/
 163 // ---------------------------------------------------------------------
 164 /* */
 165 debSrcRecordParser::~debSrcRecordParser()
 166 {
 167    delete[] Buffer;
 168 }
 169                                                                         /*}}}*/