Browse Source

cleanup datatypes mix used in binary cache

We had a wild mixture of (unsigned) int, long and long long here without
much sense, so this commit adds a few typedefs to get some sense in the
typesystem and ensures that a ID isn't sometimes computed as int, stored
as long and compared with a long long… as this could potentially bite us
later on as the size of the archive only increases over time.
debian/1.8.y
David Kalnischkies 8 years ago
parent
commit
4ad8619bb1
  1. 2
      apt-pkg/deb/debindexfile.cc
  2. 6
      apt-pkg/deb/deblistparser.cc
  3. 8
      apt-pkg/deb/deblistparser.h
  4. 2
      apt-pkg/edsp/edspindexfile.cc
  5. 4
      apt-pkg/pkgcache.cc
  6. 190
      apt-pkg/pkgcache.h
  7. 164
      apt-pkg/pkgcachegen.cc
  8. 44
      apt-pkg/pkgcachegen.h
  9. 2
      cmdline/apt-cache.cc

2
apt-pkg/deb/debindexfile.cc

@ -619,7 +619,7 @@ bool debStatusIndex::Merge(pkgCacheGenerator &Gen,OpProgress *Prog) const
pkgCache::PkgFileIterator CFile = Gen.GetCurFile();
CFile->Size = Pkg.FileSize();
CFile->mtime = Pkg.ModificationTime();
map_ptrloc const storage = Gen.WriteUniqString("now");
map_stringitem_t const storage = Gen.WriteUniqString("now");
CFile->Archive = storage;
if (Gen.MergeList(Parser) == false)

6
apt-pkg/deb/deblistparser.cc

@ -61,7 +61,7 @@ debListParser::debListParser(FileFd *File, string const &Arch) : Tags(File),
// ListParser::UniqFindTagWrite - Find the tag and write a unq string /*{{{*/
// ---------------------------------------------------------------------
/* */
unsigned long debListParser::UniqFindTagWrite(const char *Tag)
map_stringitem_t debListParser::UniqFindTagWrite(const char *Tag)
{
const char *Start;
const char *Stop;
@ -893,7 +893,7 @@ bool debListParser::LoadReleaseInfo(pkgCache::PkgFileIterator &FileI,
{
// apt-secure does no longer download individual (per-section) Release
// file. to provide Component pinning we use the section name now
map_ptrloc const storage = WriteUniqString(component);
map_stringitem_t const storage = WriteUniqString(component);
FileI->Component = storage;
pkgTagFile TagFile(&File, File.Size());
@ -906,7 +906,7 @@ bool debListParser::LoadReleaseInfo(pkgCache::PkgFileIterator &FileI,
data = Section.FindS(TAG); \
if (data.empty() == false) \
{ \
map_ptrloc const storage = WriteUniqString(data); \
map_stringitem_t const storage = WriteUniqString(data); \
STORE = storage; \
}
APT_INRELEASE("Suite", FileI->Archive)

8
apt-pkg/deb/deblistparser.h

@ -44,12 +44,12 @@ class debListParser : public pkgCacheGenerator::ListParser
protected:
pkgTagFile Tags;
pkgTagSection Section;
unsigned long iOffset;
map_filesize_t iOffset;
std::string Arch;
std::vector<std::string> Architectures;
bool MultiArchEnabled;
unsigned long UniqFindTagWrite(const char *Tag);
map_stringitem_t UniqFindTagWrite(const char *Tag);
virtual bool ParseStatus(pkgCache::PkgIterator &Pkg,pkgCache::VerIterator &Ver);
bool ParseDepends(pkgCache::VerIterator &Ver,const char *Tag,
unsigned int Type);
@ -77,8 +77,8 @@ class debListParser : public pkgCacheGenerator::ListParser
#endif
virtual bool UsePackage(pkgCache::PkgIterator &Pkg,
pkgCache::VerIterator &Ver);
virtual unsigned long Offset() {return iOffset;};
virtual unsigned long Size() {return Section.size();};
virtual map_filesize_t Offset() {return iOffset;};
virtual map_filesize_t Size() {return Section.size();};
virtual bool Step();

2
apt-pkg/edsp/edspindexfile.cc

@ -56,7 +56,7 @@ bool edspIndex::Merge(pkgCacheGenerator &Gen,OpProgress *Prog) const
pkgCache::PkgFileIterator CFile = Gen.GetCurFile();
CFile->Size = Pkg.FileSize();
CFile->mtime = Pkg.ModificationTime();
map_ptrloc const storage = Gen.WriteUniqString("edsp::scenario");
map_stringitem_t const storage = Gen.WriteUniqString("edsp::scenario");
CFile->Archive = storage;
if (Gen.MergeList(Parser) == false)

4
apt-pkg/pkgcache.cc

@ -188,7 +188,7 @@ bool pkgCache::ReMap(bool const &Errorchecks)
/* This is used to generate the hash entries for the HashTable. With my
package list from bo this function gets 94% table usage on a 512 item
table (480 used items) */
unsigned long pkgCache::sHash(const string &Str) const
map_id_t pkgCache::sHash(const string &Str) const
{
unsigned long Hash = 0;
for (string::const_iterator I = Str.begin(); I != Str.end(); ++I)
@ -196,7 +196,7 @@ unsigned long pkgCache::sHash(const string &Str) const
return Hash % HeaderP->HashTableSize;
}
unsigned long pkgCache::sHash(const char *Str) const
map_id_t pkgCache::sHash(const char *Str) const
{
unsigned long Hash = tolower_ascii(*Str);
for (const char *I = Str + 1; *I != 0; ++I)

190
apt-pkg/pkgcache.h

@ -79,11 +79,23 @@
#include <string>
#include <time.h>
#include <stdint.h>
#ifndef APT_8_CLEANER_HEADERS
using std::string;
#endif
// storing file sizes of indexes, which are way below 4 GB for now
typedef uint32_t map_filesize_t;
// each package/group/dependency gets an id
typedef uint32_t map_id_t;
// some files get an id, too, but in far less absolute numbers
typedef uint16_t map_fileid_t;
// relative pointer from cache start
typedef uint32_t map_pointer_t;
// same as the previous, but documented to be to a string item
typedef map_pointer_t map_stringitem_t;
class pkgVersioningSystem;
class pkgCache /*{{{*/
{
@ -158,8 +170,8 @@ class pkgCache /*{{{*/
std::string CacheFile;
MMap &Map;
unsigned long sHash(const std::string &S) const APT_PURE;
unsigned long sHash(const char *S) const APT_PURE;
map_id_t sHash(const std::string &S) const APT_PURE;
map_id_t sHash(const char *S) const APT_PURE;
public:
@ -183,8 +195,8 @@ class pkgCache /*{{{*/
inline void *DataEnd() {return ((unsigned char *)Map.Data()) + Map.Size();}
// String hashing function (512 range)
inline unsigned long Hash(const std::string &S) const {return sHash(S);}
inline unsigned long Hash(const char *S) const {return sHash(S);}
inline map_id_t Hash(const std::string &S) const {return sHash(S);}
inline map_id_t Hash(const char *S) const {return sHash(S);}
// Useful transformation things
const char *Priority(unsigned char Priority);
@ -263,37 +275,37 @@ struct pkgCache::Header
These indicate the number of each structure contained in the cache.
PackageCount is especially useful for generating user state structures.
See Package::Id for more info. */
unsigned long GroupCount;
unsigned long PackageCount;
unsigned long VersionCount;
unsigned long DescriptionCount;
unsigned long DependsCount;
unsigned long PackageFileCount;
unsigned long VerFileCount;
unsigned long DescFileCount;
unsigned long ProvidesCount;
map_id_t GroupCount;
map_id_t PackageCount;
map_id_t VersionCount;
map_id_t DescriptionCount;
map_id_t DependsCount;
map_fileid_t PackageFileCount;
map_fileid_t VerFileCount;
map_fileid_t DescFileCount;
map_id_t ProvidesCount;
/** \brief index of the first PackageFile structure
The PackageFile structures are singly linked lists that represent
all package files that have been merged into the cache. */
map_ptrloc FileList;
map_pointer_t FileList;
/** \brief index of the first StringItem structure
The cache contains a list of all the unique strings (StringItems).
The parser reads this list into memory so it can match strings
against it.*/
map_ptrloc StringList;
map_pointer_t StringList;
/** \brief String representing the version system used */
map_ptrloc VerSysName;
map_pointer_t VerSysName;
/** \brief native architecture the cache was built against */
map_ptrloc Architecture;
map_pointer_t Architecture;
/** \brief all architectures the cache was built against */
map_ptrloc Architectures;
map_pointer_t Architectures;
/** \brief The maximum size of a raw entry from the original Package file */
unsigned long MaxVerFileSize;
map_filesize_t MaxVerFileSize;
/** \brief The maximum size of a raw entry from the original Translation file */
unsigned long MaxDescFileSize;
map_filesize_t MaxDescFileSize;
/** \brief The Pool structures manage the allocation pools that the generator uses
@ -316,11 +328,11 @@ struct pkgCache::Header
these packages are stored as a sequence in the list.
The size of both tables is the same. */
unsigned int HashTableSize;
map_ptrloc * PkgHashTable() const { return (map_ptrloc*) (this + 1); }
map_ptrloc * GrpHashTable() const { return PkgHashTable() + HashTableSize; }
map_pointer_t * PkgHashTable() const { return (map_pointer_t*) (this + 1); }
map_pointer_t * GrpHashTable() const { return PkgHashTable() + HashTableSize; }
/** \brief Size of the complete cache file */
unsigned long CacheFileSize;
unsigned long long CacheFileSize;
bool CheckSizes(Header &Against) const APT_PURE;
Header();
@ -336,17 +348,17 @@ struct pkgCache::Header
struct pkgCache::Group
{
/** \brief Name of the group */
map_ptrloc Name; // StringItem
map_stringitem_t Name;
// Linked List
/** \brief Link to the first package which belongs to the group */
map_ptrloc FirstPackage; // Package
map_pointer_t FirstPackage; // Package
/** \brief Link to the last package which belongs to the group */
map_ptrloc LastPackage; // Package
map_pointer_t LastPackage; // Package
/** \brief Link to the next Group */
map_ptrloc Next; // Group
map_pointer_t Next; // Group
/** \brief unique sequel ID */
unsigned int ID;
map_id_t ID;
};
/*}}}*/
@ -365,9 +377,9 @@ struct pkgCache::Group
struct pkgCache::Package
{
/** \brief Name of the package */
map_ptrloc Name; // StringItem
map_stringitem_t Name;
/** \brief Architecture of the package */
map_ptrloc Arch; // StringItem
map_stringitem_t Arch;
/** \brief Base of a singly linked list of versions
Each structure represents a unique version of the package.
@ -377,24 +389,24 @@ struct pkgCache::Package
versions of a package can be cleanly handled by the system.
Furthermore, this linked list is guaranteed to be sorted
from Highest version to lowest version with no duplicate entries. */
map_ptrloc VersionList; // Version
map_pointer_t VersionList; // Version
/** \brief index to the installed version */
map_ptrloc CurrentVer; // Version
map_pointer_t CurrentVer; // Version
/** \brief indicates the deduced section
Should be the index to the string "Unknown" or to the section
of the last parsed item. */
map_ptrloc Section; // StringItem
map_stringitem_t Section;
/** \brief index of the group this package belongs to */
map_ptrloc Group; // Group the Package belongs to
map_pointer_t Group; // Group the Package belongs to
// Linked list
/** \brief Link to the next package in the same bucket */
map_ptrloc Next; // Package
map_pointer_t Next; // Package
/** \brief List of all dependencies on this package */
map_ptrloc RevDepends; // Dependency
map_pointer_t RevDepends; // Dependency
/** \brief List of all "packages" this package provide */
map_ptrloc ProvidesList; // Provides
map_pointer_t ProvidesList; // Provides
// Install/Remove/Purge etc
/** \brief state that the user wishes the package to be in */
@ -414,7 +426,7 @@ struct pkgCache::Package
This allows clients to create an array of size PackageCount and use it to store
state information for the package map. For instance the status file emitter uses
this to track which packages have been emitted already. */
unsigned int ID;
map_id_t ID;
/** \brief some useful indicators of the package's state */
unsigned long Flags;
};
@ -428,30 +440,30 @@ struct pkgCache::Package
struct pkgCache::PackageFile
{
/** \brief physical disk file that this PackageFile represents */
map_ptrloc FileName; // StringItem
map_pointer_t FileName; // StringItem
/** \brief the release information
Please see the files document for a description of what the
release information means. */
map_ptrloc Archive; // StringItem
map_ptrloc Codename; // StringItem
map_ptrloc Component; // StringItem
map_ptrloc Version; // StringItem
map_ptrloc Origin; // StringItem
map_ptrloc Label; // StringItem
map_ptrloc Architecture; // StringItem
map_stringitem_t Archive;
map_stringitem_t Codename;
map_stringitem_t Component;
map_stringitem_t Version;
map_stringitem_t Origin;
map_stringitem_t Label;
map_stringitem_t Architecture;
/** \brief The site the index file was fetched from */
map_ptrloc Site; // StringItem
map_stringitem_t Site;
/** \brief indicates what sort of index file this is
@TODO enumerate at least the possible indexes */
map_ptrloc IndexType; // StringItem
map_stringitem_t IndexType;
/** \brief Size of the file
Used together with the modification time as a
simple check to ensure that the Packages
file has not been altered since Cache generation. */
unsigned long Size;
map_filesize_t Size;
/** \brief Modification time for the file */
time_t mtime;
@ -460,9 +472,9 @@ struct pkgCache::PackageFile
// Linked list
/** \brief Link to the next PackageFile in the Cache */
map_ptrloc NextFile; // PackageFile
map_pointer_t NextFile; // PackageFile
/** \brief unique sequel ID */
unsigned int ID;
map_fileid_t ID;
};
/*}}}*/
// VerFile structure /*{{{*/
@ -473,13 +485,13 @@ struct pkgCache::PackageFile
struct pkgCache::VerFile
{
/** \brief index of the package file that this version was found in */
map_ptrloc File; // PackageFile
map_pointer_t File; // PackageFile
/** \brief next step in the linked list */
map_ptrloc NextFile; // PkgVerFile
map_pointer_t NextFile; // PkgVerFile
/** \brief position in the package file */
map_ptrloc Offset; // File offset
map_filesize_t Offset; // File offset
/** @TODO document pkgCache::VerFile::Size */
unsigned long Size;
map_filesize_t Size;
};
/*}}}*/
// DescFile structure /*{{{*/
@ -487,13 +499,13 @@ struct pkgCache::VerFile
struct pkgCache::DescFile
{
/** \brief index of the file that this description was found in */
map_ptrloc File; // PackageFile
map_pointer_t File; // PackageFile
/** \brief next step in the linked list */
map_ptrloc NextFile; // PkgVerFile
map_pointer_t NextFile; // PkgVerFile
/** \brief position in the file */
map_ptrloc Offset; // File offset
map_filesize_t Offset; // File offset
/** @TODO document pkgCache::DescFile::Size */
unsigned long Size;
map_filesize_t Size;
};
/*}}}*/
// Version structure /*{{{*/
@ -505,9 +517,9 @@ struct pkgCache::DescFile
struct pkgCache::Version
{
/** \brief complete version string */
map_ptrloc VerStr; // StringItem
map_stringitem_t VerStr;
/** \brief section this version is filled in */
map_ptrloc Section; // StringItem
map_stringitem_t Section;
/** \brief Multi-Arch capabilities of a package version */
enum VerMultiArch { None = 0, /*!< is the default and doesn't trigger special behaviour */
@ -529,33 +541,33 @@ struct pkgCache::Version
applies to. If FileList is 0 then this is a blank version.
The structure should also have a 0 in all other fields excluding
pkgCache::Version::VerStr and Possibly pkgCache::Version::NextVer. */
map_ptrloc FileList; // VerFile
map_pointer_t FileList; // VerFile
/** \brief next (lower or equal) version in the linked list */
map_ptrloc NextVer; // Version
map_pointer_t NextVer; // Version
/** \brief next description in the linked list */
map_ptrloc DescriptionList; // Description
map_pointer_t DescriptionList; // Description
/** \brief base of the dependency list */
map_ptrloc DependsList; // Dependency
map_pointer_t DependsList; // Dependency
/** \brief links to the owning package
This allows reverse dependencies to determine the package */
map_ptrloc ParentPkg; // Package
map_pointer_t ParentPkg; // Package
/** \brief list of pkgCache::Provides */
map_ptrloc ProvidesList; // Provides
map_pointer_t ProvidesList; // Provides
/** \brief archive size for this version
For Debian this is the size of the .deb file. */
unsigned long long Size; // These are the .deb size
uint64_t Size; // These are the .deb size
/** \brief uncompressed size for this version */
unsigned long long InstalledSize;
uint64_t InstalledSize;
/** \brief characteristic value representing this version
No two packages in existence should have the same VerStr
and Hash with different contents. */
unsigned short Hash;
/** \brief unique sequel ID */
unsigned int ID;
map_id_t ID;
/** \brief parsed priority value */
unsigned char Priority;
};
@ -568,22 +580,22 @@ struct pkgCache::Description
If the value has a 0 length then this is read using the Package
file else the Translation-CODE file is used. */
map_ptrloc language_code; // StringItem
map_stringitem_t language_code;
/** \brief MD5sum of the original description
Used to map Translations of a description to a version
and to check that the Translation is up-to-date. */
map_ptrloc md5sum; // StringItem
map_stringitem_t md5sum;
/** @TODO document pkgCache::Description::FileList */
map_ptrloc FileList; // DescFile
map_pointer_t FileList; // DescFile
/** \brief next translation for this description */
map_ptrloc NextDesc; // Description
map_pointer_t NextDesc; // Description
/** \brief the text is a description of this package */
map_ptrloc ParentPkg; // Package
map_pointer_t ParentPkg; // Package
/** \brief unique sequel ID */
unsigned int ID;
map_id_t ID;
};
/*}}}*/
// Dependency structure /*{{{*/
@ -596,21 +608,21 @@ struct pkgCache::Description
struct pkgCache::Dependency
{
/** \brief string of the version the dependency is applied against */
map_ptrloc Version; // StringItem
map_stringitem_t Version; // StringItem
/** \brief index of the package this depends applies to
The generator will - if the package does not already exist -
create a blank (no version records) package. */
map_ptrloc Package; // Package
map_pointer_t Package; // Package
/** \brief next dependency of this version */
map_ptrloc NextDepends; // Dependency
map_pointer_t NextDepends; // Dependency
/** \brief next reverse dependency of this package */
map_ptrloc NextRevDepends; // Dependency
map_pointer_t NextRevDepends; // Dependency
/** \brief version of the package which has the reverse depends */
map_ptrloc ParentVer; // Version
map_pointer_t ParentVer; // Version
/** \brief unique sequel ID */
map_ptrloc ID;
map_id_t ID;
/** \brief Dependency type - Depends, Recommends, Conflicts, etc */
unsigned char Type;
/** \brief comparison operator specified on the depends line
@ -631,19 +643,19 @@ struct pkgCache::Dependency
struct pkgCache::Provides
{
/** \brief index of the package providing this */
map_ptrloc ParentPkg; // Package
map_pointer_t ParentPkg; // Package
/** \brief index of the version this provide line applies to */
map_ptrloc Version; // Version
map_pointer_t Version; // Version
/** \brief version in the provides line (if any)
This version allows dependencies to depend on specific versions of a
Provides, as well as allowing Provides to override existing packages.
This is experimental. Note that Debian doesn't allow versioned provides */
map_ptrloc ProvideVersion; // StringItem
map_stringitem_t ProvideVersion;
/** \brief next provides (based of package) */
map_ptrloc NextProvides; // Provides
map_pointer_t NextProvides; // Provides
/** \brief next provides (based of version) */
map_ptrloc NextPkgProv; // Provides
map_pointer_t NextPkgProv; // Provides
};
/*}}}*/
// StringItem structure /*{{{*/
@ -658,9 +670,9 @@ struct pkgCache::Provides
struct pkgCache::StringItem
{
/** \brief string this refers to */
map_ptrloc String; // StringItem
map_stringitem_t String;
/** \brief Next link in the chain */
map_ptrloc NextItem; // StringItem
map_stringitem_t NextItem;
};
/*}}}*/

164
apt-pkg/pkgcachegen.cc

@ -75,16 +75,16 @@ pkgCacheGenerator::pkgCacheGenerator(DynamicMMap *pMap,OpProgress *Prog) :
*Cache.HeaderP = pkgCache::Header();
// make room for the hashtables for packages and groups
if (Map.RawAllocate(2 * (Cache.HeaderP->HashTableSize * sizeof(map_ptrloc))) == 0)
if (Map.RawAllocate(2 * (Cache.HeaderP->HashTableSize * sizeof(map_pointer_t))) == 0)
return;
map_ptrloc const idxVerSysName = WriteStringInMap(_system->VS->Label);
map_stringitem_t const idxVerSysName = WriteStringInMap(_system->VS->Label);
if (unlikely(idxVerSysName == 0))
return;
Cache.HeaderP->VerSysName = idxVerSysName;
// this pointer is set in ReMap, but we need it now for WriteUniqString
Cache.StringItemP = (pkgCache::StringItem *)Map.Data();
map_ptrloc const idxArchitecture = WriteUniqString(_config->Find("APT::Architecture"));
map_stringitem_t const idxArchitecture = WriteUniqString(_config->Find("APT::Architecture"));
if (unlikely(idxArchitecture == 0))
return;
Cache.HeaderP->Architecture = idxArchitecture;
@ -96,7 +96,7 @@ pkgCacheGenerator::pkgCacheGenerator(DynamicMMap *pMap,OpProgress *Prog) :
std::string list = *a;
for (++a; a != archs.end(); ++a)
list.append(",").append(*a);
map_ptrloc const idxArchitectures = WriteStringInMap(list);
map_stringitem_t const idxArchitectures = WriteStringInMap(list);
if (unlikely(idxArchitectures == 0))
return;
Cache.HeaderP->Architectures = idxArchitectures;
@ -176,27 +176,27 @@ void pkgCacheGenerator::ReMap(void const * const oldMap, void const * const newM
(*i)->ReMap(oldMap, newMap);
} /*}}}*/
// CacheGenerator::WriteStringInMap /*{{{*/
map_ptrloc pkgCacheGenerator::WriteStringInMap(const char *String,
map_stringitem_t pkgCacheGenerator::WriteStringInMap(const char *String,
const unsigned long &Len) {
void const * const oldMap = Map.Data();
map_ptrloc const index = Map.WriteString(String, Len);
map_stringitem_t const index = Map.WriteString(String, Len);
if (index != 0)
ReMap(oldMap, Map.Data());
return index;
}
/*}}}*/
// CacheGenerator::WriteStringInMap /*{{{*/
map_ptrloc pkgCacheGenerator::WriteStringInMap(const char *String) {
map_stringitem_t pkgCacheGenerator::WriteStringInMap(const char *String) {
void const * const oldMap = Map.Data();
map_ptrloc const index = Map.WriteString(String);
map_stringitem_t const index = Map.WriteString(String);
if (index != 0)
ReMap(oldMap, Map.Data());
return index;
}
/*}}}*/
map_ptrloc pkgCacheGenerator::AllocateInMap(const unsigned long &size) {/*{{{*/
map_pointer_t pkgCacheGenerator::AllocateInMap(const unsigned long &size) {/*{{{*/
void const * const oldMap = Map.Data();
map_ptrloc const index = Map.Allocate(size);
map_pointer_t const index = Map.Allocate(size);
if (index != 0)
ReMap(oldMap, Map.Data());
return index;
@ -276,16 +276,16 @@ bool pkgCacheGenerator::MergeList(ListParser &List,
}
}
if (Cache.HeaderP->PackageCount >= (1ULL<<sizeof(Cache.PkgP->ID)*8)-1)
if (Cache.HeaderP->PackageCount >= std::numeric_limits<map_id_t>::max())
return _error->Error(_("Wow, you exceeded the number of package "
"names this APT is capable of."));
if (Cache.HeaderP->VersionCount >= (1ULL<<(sizeof(Cache.VerP->ID)*8))-1)
if (Cache.HeaderP->VersionCount >= std::numeric_limits<map_id_t>::max())
return _error->Error(_("Wow, you exceeded the number of versions "
"this APT is capable of."));
if (Cache.HeaderP->DescriptionCount >= (1ULL<<(sizeof(Cache.DescP->ID)*8))-1)
if (Cache.HeaderP->DescriptionCount >= std::numeric_limits<map_id_t>::max())
return _error->Error(_("Wow, you exceeded the number of descriptions "
"this APT is capable of."));
if (Cache.HeaderP->DependsCount >= (1ULL<<(sizeof(Cache.DepP->ID)*8))-1ULL)
if (Cache.HeaderP->DependsCount >= std::numeric_limits<map_id_t>::max())
return _error->Error(_("Wow, you exceeded the number of dependencies "
"this APT is capable of."));
@ -336,7 +336,7 @@ bool pkgCacheGenerator::MergeListPackage(ListParser &List, pkgCache::PkgIterator
if (VerDesc.end() == true || MD5SumValue(VerDesc.md5()) != CurMd5)
continue;
map_ptrloc md5idx = VerDesc->md5sum;
map_stringitem_t md5idx = VerDesc->md5sum;
for (std::vector<std::string>::const_iterator CurLang = availDesc.begin(); CurLang != availDesc.end(); ++CurLang)
{
// don't add a new description if we have one for the given
@ -360,7 +360,7 @@ bool pkgCacheGenerator::MergeListVersion(ListParser &List, pkgCache::PkgIterator
{
pkgCache::VerIterator Ver = Pkg.VersionList();
Dynamic<pkgCache::VerIterator> DynVer(Ver);
map_ptrloc *LastVer = &Pkg->VersionList;
map_pointer_t *LastVer = &Pkg->VersionList;
void const * oldMap = Map.Data();
unsigned short const Hash = List.VersionHash();
@ -405,13 +405,13 @@ bool pkgCacheGenerator::MergeListVersion(ListParser &List, pkgCache::PkgIterator
}
// Add a new version
map_ptrloc const verindex = NewVersion(Ver, Version, Pkg.Index(), Hash, *LastVer);
map_pointer_t const verindex = NewVersion(Ver, Version, Pkg.Index(), Hash, *LastVer);
if (verindex == 0 && _error->PendingError())
return _error->Error(_("Error occurred while processing %s (%s%d)"),
Pkg.Name(), "NewVersion", 1);
if (oldMap != Map.Data())
LastVer += (map_ptrloc const * const) Map.Data() - (map_ptrloc const * const) oldMap;
LastVer += (map_pointer_t const * const) Map.Data() - (map_pointer_t const * const) oldMap;
*LastVer = verindex;
if (unlikely(List.NewVersion(Ver) == false))
@ -472,7 +472,7 @@ bool pkgCacheGenerator::MergeListVersion(ListParser &List, pkgCache::PkgIterator
D.ParentPkg().Group() == Grp)
continue;
map_ptrloc *OldDepLast = NULL;
map_pointer_t *OldDepLast = NULL;
pkgCache::VerIterator ConVersion = D.ParentVer();
Dynamic<pkgCache::VerIterator> DynV(ConVersion);
// duplicate the Conflicts/Breaks/Replaces for :none arch
@ -514,7 +514,7 @@ bool pkgCacheGenerator::MergeListVersion(ListParser &List, pkgCache::PkgIterator
}
// We haven't found reusable descriptions, so add the first description(s)
map_ptrloc md5idx = Ver->DescriptionList == 0 ? 0 : Ver.DescriptionList()->md5sum;
map_stringitem_t md5idx = Ver->DescriptionList == 0 ? 0 : Ver.DescriptionList()->md5sum;
std::vector<std::string> availDesc = List.AvailableDescriptionLanguages();
for (std::vector<std::string>::const_iterator CurLang = availDesc.begin(); CurLang != availDesc.end(); ++CurLang)
if (AddNewDescription(List, Ver, *CurLang, CurMd5, md5idx) == false)
@ -522,12 +522,12 @@ bool pkgCacheGenerator::MergeListVersion(ListParser &List, pkgCache::PkgIterator
return true;
}
/*}}}*/
bool pkgCacheGenerator::AddNewDescription(ListParser &List, pkgCache::VerIterator &Ver, std::string const &lang, MD5SumValue const &CurMd5, map_ptrloc &md5idx) /*{{{*/
bool pkgCacheGenerator::AddNewDescription(ListParser &List, pkgCache::VerIterator &Ver, std::string const &lang, MD5SumValue const &CurMd5, map_stringitem_t &md5idx) /*{{{*/
{
pkgCache::DescIterator Desc;
Dynamic<pkgCache::DescIterator> DynDesc(Desc);
map_ptrloc const descindex = NewDescription(Desc, lang, CurMd5, md5idx);
map_pointer_t const descindex = NewDescription(Desc, lang, CurMd5, md5idx);
if (unlikely(descindex == 0 && _error->PendingError()))
return _error->Error(_("Error occurred while processing %s (%s%d)"),
Ver.ParentPkg().Name(), "NewDescription", 1);
@ -539,7 +539,7 @@ bool pkgCacheGenerator::AddNewDescription(ListParser &List, pkgCache::VerIterato
// that to be able to efficiently share these lists
pkgCache::DescIterator VerDesc = Ver.DescriptionList(); // old value might be invalid after ReMap
for (;VerDesc.end() == false && VerDesc->NextDesc != 0; ++VerDesc);
map_ptrloc * const LastNextDesc = (VerDesc.end() == true) ? &Ver->DescriptionList : &VerDesc->NextDesc;
map_pointer_t * const LastNextDesc = (VerDesc.end() == true) ? &Ver->DescriptionList : &VerDesc->NextDesc;
*LastNextDesc = descindex;
if (NewFileDesc(Desc,List) == false)
@ -611,19 +611,19 @@ bool pkgCacheGenerator::NewGroup(pkgCache::GrpIterator &Grp, const string &Name)
return true;
// Get a structure
map_ptrloc const Group = AllocateInMap(sizeof(pkgCache::Group));
map_pointer_t const Group = AllocateInMap(sizeof(pkgCache::Group));
if (unlikely(Group == 0))
return false;
Grp = pkgCache::GrpIterator(Cache, Cache.GrpP + Group);
map_ptrloc const idxName = WriteStringInMap(Name);
map_pointer_t const idxName = WriteStringInMap(Name);
if (unlikely(idxName == 0))
return false;
Grp->Name = idxName;
// Insert it into the hash table
unsigned long const Hash = Cache.Hash(Name);
map_ptrloc *insertAt = &Cache.HeaderP->GrpHashTable()[Hash];
map_pointer_t *insertAt = &Cache.HeaderP->GrpHashTable()[Hash];
while (*insertAt != 0 && strcasecmp(Name.c_str(), Cache.StrP + (Cache.GrpP + *insertAt)->Name) > 0)
insertAt = &(Cache.GrpP + *insertAt)->Next;
Grp->Next = *insertAt;
@ -648,7 +648,7 @@ bool pkgCacheGenerator::NewPackage(pkgCache::PkgIterator &Pkg,const string &Name
return true;
// Get a structure
map_ptrloc const Package = AllocateInMap(sizeof(pkgCache::Package));
map_pointer_t const Package = AllocateInMap(sizeof(pkgCache::Package));
if (unlikely(Package == 0))
return false;
Pkg = pkgCache::PkgIterator(Cache,Cache.PkgP + Package);
@ -658,8 +658,8 @@ bool pkgCacheGenerator::NewPackage(pkgCache::PkgIterator &Pkg,const string &Name
{
Grp->FirstPackage = Package;
// Insert it into the hash table
unsigned long const Hash = Cache.Hash(Name);
map_ptrloc *insertAt = &Cache.HeaderP->PkgHashTable()[Hash];
map_id_t const Hash = Cache.Hash(Name);
map_pointer_t *insertAt = &Cache.HeaderP->PkgHashTable()[Hash];
while (*insertAt != 0 && strcasecmp(Name.c_str(), Cache.StrP + (Cache.PkgP + *insertAt)->Name) > 0)
insertAt = &(Cache.PkgP + *insertAt)->Next;
Pkg->Next = *insertAt;
@ -678,7 +678,7 @@ bool pkgCacheGenerator::NewPackage(pkgCache::PkgIterator &Pkg,const string &Name
Pkg->Name = Grp->Name;
Pkg->Group = Grp.Index();
// all is mapped to the native architecture
map_ptrloc const idxArch = (Arch == "all") ? Cache.HeaderP->Architecture : WriteUniqString(Arch.c_str());
map_stringitem_t const idxArch = (Arch == "all") ? Cache.HeaderP->Architecture : WriteUniqString(Arch.c_str());
if (unlikely(idxArch == 0))
return false;
Pkg->Arch = idxArch;
@ -695,14 +695,14 @@ bool pkgCacheGenerator::AddImplicitDepends(pkgCache::GrpIterator &G,
// copy P.Arch() into a string here as a cache remap
// in NewDepends() later may alter the pointer location
string Arch = P.Arch() == NULL ? "" : P.Arch();
map_ptrloc *OldDepLast = NULL;
map_pointer_t *OldDepLast = NULL;
/* MultiArch handling introduces a lot of implicit Dependencies:
- MultiArch: same Co-Installable if they have the same version
- All others conflict with all other group members */
bool const coInstall = ((V->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same);
pkgCache::PkgIterator D = G.PackageList();
Dynamic<pkgCache::PkgIterator> DynD(D);
map_ptrloc const VerStrIdx = V->VerStr;
map_stringitem_t const VerStrIdx = V->VerStr;
for (; D.end() != true; D = G.NextPkg(D))
{
if (Arch == D.Arch() || D->VersionList == 0)
@ -735,11 +735,11 @@ bool pkgCacheGenerator::AddImplicitDepends(pkgCache::VerIterator &V,
/* MultiArch handling introduces a lot of implicit Dependencies:
- MultiArch: same Co-Installable if they have the same version
- All others conflict with all other group members */
map_ptrloc *OldDepLast = NULL;
map_pointer_t *OldDepLast = NULL;
bool const coInstall = ((V->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same);
if (coInstall == true)
{
map_ptrloc const VerStrIdx = V->VerStr;
map_stringitem_t const VerStrIdx = V->VerStr;
// Replaces: ${self}:other ( << ${binary:Version})
NewDepends(D, V, VerStrIdx,
pkgCache::Dep::Less, pkgCache::Dep::Replaces,
@ -768,7 +768,7 @@ bool pkgCacheGenerator::NewFileVer(pkgCache::VerIterator &Ver,
return true;
// Get a structure
map_ptrloc const VerFile = AllocateInMap(sizeof(pkgCache::VerFile));
map_pointer_t const VerFile = AllocateInMap(sizeof(pkgCache::VerFile));
if (VerFile == 0)
return 0;
@ -776,7 +776,7 @@ bool pkgCacheGenerator::NewFileVer(pkgCache::VerIterator &Ver,
VF->File = CurrentFile - Cache.PkgFileP;
// Link it to the end of the list
map_ptrloc *Last = &Ver->FileList;
map_pointer_t *Last = &Ver->FileList;
for (pkgCache::VerFileIterator V = Ver.FileList(); V.end() == false; ++V)
Last = &V->NextFile;
VF->NextFile = *Last;
@ -794,14 +794,14 @@ bool pkgCacheGenerator::NewFileVer(pkgCache::VerIterator &Ver,
// CacheGenerator::NewVersion - Create a new Version /*{{{*/
// ---------------------------------------------------------------------
/* This puts a version structure in the linked list */
unsigned long pkgCacheGenerator::NewVersion(pkgCache::VerIterator &Ver,
map_pointer_t pkgCacheGenerator::NewVersion(pkgCache::VerIterator &Ver,
const string &VerStr,
map_ptrloc const ParentPkg,
unsigned long const Hash,
unsigned long Next)
map_pointer_t const ParentPkg,
unsigned short const Hash,
map_pointer_t const Next)
{
// Get a structure
map_ptrloc const Version = AllocateInMap(sizeof(pkgCache::Version));
map_pointer_t const Version = AllocateInMap(sizeof(pkgCache::Version));
if (Version == 0)
return 0;
@ -836,7 +836,7 @@ unsigned long pkgCacheGenerator::NewVersion(pkgCache::VerIterator &Ver,
}
}
// haven't found the version string, so create
map_ptrloc const idxVerStr = WriteStringInMap(VerStr);
map_stringitem_t const idxVerStr = WriteStringInMap(VerStr);
if (unlikely(idxVerStr == 0))
return 0;
Ver->VerStr = idxVerStr;
@ -853,7 +853,7 @@ bool pkgCacheGenerator::NewFileDesc(pkgCache::DescIterator &Desc,
return true;
// Get a structure
map_ptrloc const DescFile = AllocateInMap(sizeof(pkgCache::DescFile));
map_pointer_t const DescFile = AllocateInMap(sizeof(pkgCache::DescFile));
if (DescFile == 0)
return false;
@ -861,7 +861,7 @@ bool pkgCacheGenerator::NewFileDesc(pkgCache::DescIterator &Desc,
DF->File = CurrentFile - Cache.PkgFileP;
// Link it to the end of the list
map_ptrloc *Last = &Desc->FileList;
map_pointer_t *Last = &Desc->FileList;
for (pkgCache::DescFileIterator D = Desc.FileList(); D.end() == false; ++D)
Last = &D->NextFile;
@ -880,20 +880,20 @@ bool pkgCacheGenerator::NewFileDesc(pkgCache::DescIterator &Desc,
// CacheGenerator::NewDescription - Create a new Description /*{{{*/
// ---------------------------------------------------------------------
/* This puts a description structure in the linked list */
map_ptrloc pkgCacheGenerator::NewDescription(pkgCache::DescIterator &Desc,
map_pointer_t pkgCacheGenerator::NewDescription(pkgCache::DescIterator &Desc,
const string &Lang,
const MD5SumValue &md5sum,
map_ptrloc idxmd5str)
map_stringitem_t const idxmd5str)
{
// Get a structure
map_ptrloc const Description = AllocateInMap(sizeof(pkgCache::Description));
map_pointer_t const Description = AllocateInMap(sizeof(pkgCache::Description));
if (Description == 0)
return 0;
// Fill it in
Desc = pkgCache::DescIterator(Cache,Cache.DescP + Description);
Desc->ID = Cache.HeaderP->DescriptionCount++;
map_ptrloc const idxlanguage_code = WriteUniqString(Lang);
map_stringitem_t const idxlanguage_code = WriteUniqString(Lang);
if (unlikely(idxlanguage_code == 0))
return 0;
Desc->language_code = idxlanguage_code;
@ -902,7 +902,7 @@ map_ptrloc pkgCacheGenerator::NewDescription(pkgCache::DescIterator &Desc,
Desc->md5sum = idxmd5str;
else
{
map_ptrloc const idxmd5sum = WriteStringInMap(md5sum.Value());
map_stringitem_t const idxmd5sum = WriteStringInMap(md5sum.Value());
if (unlikely(idxmd5sum == 0))
return 0;
Desc->md5sum = idxmd5sum;
@ -920,9 +920,9 @@ bool pkgCacheGenerator::NewDepends(pkgCache::PkgIterator &Pkg,
string const &Version,
unsigned int const &Op,
unsigned int const &Type,
map_ptrloc* &OldDepLast)
map_stringitem_t* &OldDepLast)
{
map_ptrloc index = 0;
map_stringitem_t index = 0;
if (Version.empty() == false)
{
int const CmpOp = Op & 0x0F;
@ -937,21 +937,21 @@ bool pkgCacheGenerator::NewDepends(pkgCache::PkgIterator &Pkg,
if (unlikely(index == 0))
return false;
if (OldDepLast != 0 && oldMap != Map.Data())
OldDepLast += (map_ptrloc const * const) Map.Data() - (map_ptrloc const * const) oldMap;
OldDepLast += (map_pointer_t const * const) Map.Data() - (map_pointer_t const * const) oldMap;
}
}
return NewDepends(Pkg, Ver, index, Op, Type, OldDepLast);
}
bool pkgCacheGenerator::NewDepends(pkgCache::PkgIterator &Pkg,
pkgCache::VerIterator &Ver,
map_ptrloc const Version,
map_pointer_t const Version,
unsigned int const &Op,
unsigned int const &Type,
map_ptrloc* &OldDepLast)
map_pointer_t* &OldDepLast)
{
void const * const oldMap = Map.Data();
// Get a structure
map_ptrloc const Dependency = AllocateInMap(sizeof(pkgCache::Dependency));
map_pointer_t const Dependency = AllocateInMap(sizeof(pkgCache::Dependency));
if (unlikely(Dependency == 0))
return false;
@ -976,7 +976,7 @@ bool pkgCacheGenerator::NewDepends(pkgCache::PkgIterator &Pkg,
for (pkgCache::DepIterator D = Ver.DependsList(); D.end() == false; ++D)
OldDepLast = &D->NextDepends;
} else if (oldMap != Map.Data())
OldDepLast += (map_ptrloc const * const) Map.Data() - (map_ptrloc const * const) oldMap;
OldDepLast += (map_pointer_t const * const) Map.Data() - (map_pointer_t const * const) oldMap;
Dep->NextDepends = *OldDepLast;
*OldDepLast = Dep.Index();
@ -1041,7 +1041,7 @@ bool pkgCacheGenerator::ListParser::NewProvides(pkgCache::VerIterator &Ver,
return true;
// Get a structure
map_ptrloc const Provides = Owner->AllocateInMap(sizeof(pkgCache::Provides));
map_pointer_t const Provides = Owner->AllocateInMap(sizeof(pkgCache::Provides));
if (unlikely(Provides == 0))
return false;
Cache.HeaderP->ProvidesCount++;
@ -1053,7 +1053,7 @@ bool pkgCacheGenerator::ListParser::NewProvides(pkgCache::VerIterator &Ver,
Prv->NextPkgProv = Ver->ProvidesList;
Ver->ProvidesList = Prv.Index();
if (Version.empty() == false) {
map_ptrloc const idxProvideVersion = WriteString(Version);
map_stringitem_t const idxProvideVersion = WriteString(Version);
Prv->ProvideVersion = idxProvideVersion;
if (unlikely(idxProvideVersion == 0))
return false;
@ -1088,14 +1088,14 @@ bool pkgCacheGenerator::SelectFile(const string &File,const string &Site,
unsigned long Flags)
{
// Get some space for the structure
map_ptrloc const idxFile = AllocateInMap(sizeof(*CurrentFile));
map_pointer_t const idxFile = AllocateInMap(sizeof(*CurrentFile));
if (unlikely(idxFile == 0))
return false;
CurrentFile = Cache.PkgFileP + idxFile;
// Fill it in
map_ptrloc const idxFileName = WriteStringInMap(File);
map_ptrloc const idxSite = WriteUniqString(Site);
map_stringitem_t const idxFileName = WriteStringInMap(File);
map_stringitem_t const idxSite = WriteUniqString(Site);
if (unlikely(idxFileName == 0 || idxSite == 0))
return false;
CurrentFile->FileName = idxFileName;
@ -1103,7 +1103,7 @@ bool pkgCacheGenerator::SelectFile(const string &File,const string &Site,
CurrentFile->NextFile = Cache.HeaderP->FileList;
CurrentFile->Flags = Flags;
CurrentFile->ID = Cache.HeaderP->PackageFileCount;
map_ptrloc const idxIndexType = WriteUniqString(Index.GetType()->Label);
map_stringitem_t const idxIndexType = WriteUniqString(Index.GetType()->Label);
if (unlikely(idxIndexType == 0))
return false;
CurrentFile->IndexType = idxIndexType;
@ -1120,7 +1120,7 @@ bool pkgCacheGenerator::SelectFile(const string &File,const string &Site,
// ---------------------------------------------------------------------
/* This is used to create handles to strings. Given the same text it
always returns the same number */
unsigned long pkgCacheGenerator::WriteUniqString(const char *S,
map_stringitem_t pkgCacheGenerator::WriteUniqString(const char *S,
unsigned int Size)
{
/* We use a very small transient hash table here, this speeds up generation
@ -1133,7 +1133,7 @@ unsigned long pkgCacheGenerator::WriteUniqString(const char *S,
// Search for an insertion point
pkgCache::StringItem *I = Cache.StringItemP + Cache.HeaderP->StringList;
int Res = 1;
map_ptrloc *Last = &Cache.HeaderP->StringList;
map_stringitem_t *Last = &Cache.HeaderP->StringList;
for (; I != Cache.StringItemP; Last = &I->NextItem,
I = Cache.StringItemP + I->NextItem)
{
@ -1151,15 +1151,15 @@ unsigned long pkgCacheGenerator::WriteUniqString(const char *S,
// Get a structure
void const * const oldMap = Map.Data();
map_ptrloc const Item = AllocateInMap(sizeof(pkgCache::StringItem));
map_pointer_t const Item = AllocateInMap(sizeof(pkgCache::StringItem));
if (Item == 0)
return 0;
map_ptrloc const idxString = WriteStringInMap(S,Size);
map_stringitem_t const idxString = WriteStringInMap(S,Size);
if (unlikely(idxString == 0))
return 0;
if (oldMap != Map.Data()) {
Last += (map_ptrloc const * const) Map.Data() - (map_ptrloc const * const) oldMap;
Last += (map_pointer_t const * const) Map.Data() - (map_pointer_t const * const) oldMap;
I += (pkgCache::StringItem const * const) Map.Data() - (pkgCache::StringItem const * const) oldMap;
}
*Last = Item;
@ -1280,9 +1280,9 @@ static bool CheckValidity(const string &CacheFile,
// ---------------------------------------------------------------------
/* Size is kind of an abstract notion that is only used for the progress
meter */
static unsigned long ComputeSize(FileIterator Start,FileIterator End)
static map_filesize_t ComputeSize(FileIterator Start,FileIterator End)
{
unsigned long TotalSize = 0;
map_filesize_t TotalSize = 0;
for (; Start < End; ++Start)
{
if ((*Start)->HasPackages() == false)
@ -1297,7 +1297,7 @@ static unsigned long ComputeSize(FileIterator Start,FileIterator End)
/* */
static bool BuildCache(pkgCacheGenerator &Gen,
OpProgress *Progress,
unsigned long &CurrentSize,unsigned long TotalSize,
map_filesize_t &CurrentSize,map_filesize_t TotalSize,
FileIterator Start, FileIterator End)
{
FileIterator I;
@ -1316,7 +1316,7 @@ static bool BuildCache(pkgCacheGenerator &Gen,
continue;
}
unsigned long Size = (*I)->Size();
map_filesize_t Size = (*I)->Size();
if (Progress != NULL)
Progress->OverallProgress(CurrentSize,TotalSize,Size,_("Reading package lists"));
CurrentSize += Size;
@ -1333,7 +1333,7 @@ static bool BuildCache(pkgCacheGenerator &Gen,
CurrentSize = 0;
for (I = Start; I != End; ++I)
{
unsigned long Size = (*I)->Size();
map_filesize_t Size = (*I)->Size();
if (Progress != NULL)
Progress->OverallProgress(CurrentSize,TotalSize,Size,_("Collecting File Provides"));
CurrentSize += Size;
@ -1347,9 +1347,9 @@ static bool BuildCache(pkgCacheGenerator &Gen,
/*}}}*/
// CacheGenerator::CreateDynamicMMap - load an mmap with configuration options /*{{{*/
DynamicMMap* pkgCacheGenerator::CreateDynamicMMap(FileFd *CacheF, unsigned long Flags) {
unsigned long const MapStart = _config->FindI("APT::Cache-Start", 24*1024*1024);
unsigned long const MapGrow = _config->FindI("APT::Cache-Grow", 1*1024*1024);
unsigned long const MapLimit = _config->FindI("APT::Cache-Limit", 0);
map_filesize_t const MapStart = _config->FindI("APT::Cache-Start", 24*1024*1024);
map_filesize_t const MapGrow = _config->FindI("APT::Cache-Grow", 1*1024*1024);
map_filesize_t const MapLimit = _config->FindI("APT::Cache-Limit", 0);
Flags |= MMap::Moveable;
if (_config->FindB("APT::Cache-Fallback", false) == true)
Flags |= MMap::Fallback;
@ -1387,7 +1387,7 @@ bool pkgCacheGenerator::MakeStatusCache(pkgSourceList &List,OpProgress *Progress
Files.push_back (*j);
}
unsigned long const EndOfSource = Files.size();
map_filesize_t const EndOfSource = Files.size();
if (_system->AddStatusFiles(Files) == false)
return false;
@ -1477,8 +1477,8 @@ bool pkgCacheGenerator::MakeStatusCache(pkgSourceList &List,OpProgress *Progress
}
// Lets try the source cache.
unsigned long CurrentSize = 0;
unsigned long TotalSize = 0;
map_filesize_t CurrentSize = 0;
map_filesize_t TotalSize = 0;
if (CheckValidity(SrcCacheFile, List, Files.begin(),
Files.begin()+EndOfSource) == true)
{
@ -1486,7 +1486,7 @@ bool pkgCacheGenerator::MakeStatusCache(pkgSourceList &List,OpProgress *Progress
std::clog << "srcpkgcache.bin is valid - populate MMap with it." << std::endl;
// Preload the map with the source cache
FileFd SCacheF(SrcCacheFile,FileFd::ReadOnly);
unsigned long const alloc = Map->RawAllocate(SCacheF.Size());
map_pointer_t const alloc = Map->RawAllocate(SCacheF.Size());
if ((alloc == 0 && _error->PendingError())
|| SCacheF.Read((unsigned char *)Map->Data() + alloc,
SCacheF.Size()) == false)
@ -1573,13 +1573,13 @@ APT_DEPRECATED bool pkgMakeOnlyStatusCache(OpProgress &Progress,DynamicMMap **Ou
bool pkgCacheGenerator::MakeOnlyStatusCache(OpProgress *Progress,DynamicMMap **OutMap)
{
std::vector<pkgIndexFile *> Files;
unsigned long EndOfSource = Files.size();
map_filesize_t EndOfSource = Files.size();
if (_system->AddStatusFiles(Files) == false)
return false;
SPtr<DynamicMMap> Map = CreateDynamicMMap(NULL);
unsigned long CurrentSize = 0;
unsigned long TotalSize = 0;
map_filesize_t CurrentSize = 0;
map_filesize_t TotalSize = 0;
TotalSize = ComputeSize(Files.begin()+EndOfSource,Files.end());

44
apt-pkg/pkgcachegen.h

@ -38,10 +38,10 @@ class pkgCacheGenerator /*{{{*/
private:
pkgCache::StringItem *UniqHash[26];
APT_HIDDEN map_ptrloc WriteStringInMap(std::string const &String) { return WriteStringInMap(String.c_str()); };
APT_HIDDEN map_ptrloc WriteStringInMap(const char *String);
APT_HIDDEN map_ptrloc WriteStringInMap(const char *String, const unsigned long &Len);
APT_HIDDEN map_ptrloc AllocateInMap(const unsigned long &size);
APT_HIDDEN map_stringitem_t WriteStringInMap(std::string const &String) { return WriteStringInMap(String.c_str()); };
APT_HIDDEN map_stringitem_t WriteStringInMap(const char *String);
APT_HIDDEN map_stringitem_t WriteStringInMap(const char *String, const unsigned long &Len);
APT_HIDDEN map_pointer_t AllocateInMap(const unsigned long &size);
public:
@ -78,21 +78,21 @@ class pkgCacheGenerator /*{{{*/
bool NewFileDesc(pkgCache::DescIterator &Desc,ListParser &List);
bool NewDepends(pkgCache::PkgIterator &Pkg, pkgCache::VerIterator &Ver,
std::string const &Version, unsigned int const &Op,
unsigned int const &Type, map_ptrloc* &OldDepLast);
unsigned int const &Type, map_pointer_t* &OldDepLast);
bool NewDepends(pkgCache::PkgIterator &Pkg, pkgCache::VerIterator &Ver,
map_ptrloc const Version, unsigned int const &Op,
unsigned int const &Type, map_ptrloc* &OldDepLast);
unsigned long NewVersion(pkgCache::VerIterator &Ver,const std::string &VerStr,unsigned long Next) APT_DEPRECATED
map_pointer_t const Version, unsigned int const &Op,
unsigned int const &Type, map_pointer_t* &OldDepLast);
map_pointer_t NewVersion(pkgCache::VerIterator &Ver,const std::string &VerStr,map_pointer_t const Next) APT_DEPRECATED
{ return NewVersion(Ver, VerStr, 0, 0, Next); }
unsigned long NewVersion(pkgCache::VerIterator &Ver,const std::string &VerStr,
map_ptrloc const ParentPkg, unsigned long const Hash,
unsigned long Next);
map_ptrloc NewDescription(pkgCache::DescIterator &Desc,const std::string &Lang,const MD5SumValue &md5sum,map_ptrloc Next);
map_pointer_t NewVersion(pkgCache::VerIterator &Ver,const std::string &VerStr,
map_pointer_t const ParentPkg, unsigned short const Hash,
map_pointer_t const Next);
map_pointer_t NewDescription(pkgCache::DescIterator &Desc,const std::string &Lang,const MD5SumValue &md5sum,map_stringitem_t const idxmd5str);
public:
unsigned long WriteUniqString(const char *S,unsigned int Size);
inline unsigned long WriteUniqString(const std::string &S) {return WriteUniqString(S.c_str(),S.length());};
map_stringitem_t WriteUniqString(const char *S,unsigned int const Size);
inline map_stringitem_t WriteUniqString(const std::string &S) {return WriteUniqString(S.c_str(),S.length());};
void DropProgress() {Progress = 0;};
bool SelectFile(const std::string &File,const std::string &Site,pkgIndexFile const &Index,
@ -127,7 +127,7 @@ class pkgCacheGenerator /*{{{*/
APT_HIDDEN bool AddImplicitDepends(pkgCache::VerIterator &V, pkgCache::PkgIterator &D);
APT_HIDDEN bool AddNewDescription(ListParser &List, pkgCache::VerIterator &Ver,
std::string const &lang, MD5SumValue const &CurMd5, map_ptrloc &md5idx);
std::string const &lang, MD5SumValue const &CurMd5, map_stringitem_t &md5idx);
};
/*}}}*/
// This is the abstract package list parser class. /*{{{*/
@ -138,17 +138,17 @@ class pkgCacheGenerator::ListParser
// Some cache items
pkgCache::VerIterator OldDepVer;
map_ptrloc *OldDepLast;
map_pointer_t *OldDepLast;
// Flag file dependencies
bool FoundFileDeps;
protected:
inline unsigned long WriteUniqString(std::string S) {return Owner->WriteUniqString(S);};
inline unsigned long WriteUniqString(const char *S,unsigned int Size) {return Owner->WriteUniqString(S,Size);};
inline unsigned long WriteString(const std::string &S) {return Owner->WriteStringInMap(S);};
inline unsigned long WriteString(const char *S,unsigned int Size) {return Owner->WriteStringInMap(S,Size);};
inline map_stringitem_t WriteUniqString(std::string S) {return Owner->WriteUniqString(S);};
inline map_stringitem_t WriteUniqString(const char *S,unsigned int Size) {return Owner->WriteUniqString(S,Size);};
inline map_stringitem_t WriteString(const std::string &S) {return Owner->WriteStringInMap(S);};
inline map_stringitem_t WriteString(const char *S,unsigned int Size) {return Owner->WriteStringInMap(S,Size);};
bool NewDepends(pkgCache::VerIterator &Ver,const std::string &Package, const std::string &Arch,
const std::string &Version,unsigned int Op,
unsigned int Type);
@ -178,8 +178,8 @@ class pkgCacheGenerator::ListParser
APT_PURE bool SameVersion(unsigned short const Hash, pkgCache::VerIterator const &Ver);
virtual bool UsePackage(pkgCache::PkgIterator &Pkg,
pkgCache::VerIterator &Ver) = 0;
virtual unsigned long Offset() = 0;
virtual unsigned long Size() = 0;
virtual map_filesize_t Offset() = 0;
virtual map_filesize_t Size() = 0;
virtual bool Step() = 0;

2
cmdline/apt-cache.cc

@ -1275,7 +1275,7 @@ static bool DisplayRecord(pkgCacheFile &CacheFile, pkgCache::VerIterator V)
struct ExDescFile
{
pkgCache::DescFile *Df;
map_ptrloc ID;
map_id_t ID;
};
// Search - Perform a search /*{{{*/

Loading…
Cancel
Save