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