Browse Source

Checkpoint

Author: jgg
Date: 1998-07-04 05:57:34 GMT
Checkpoint
debian/1.8.y
Arch Librarian 18 years ago
parent
commit
f55a958ff2
  1. 9
      apt-pkg/cacheiterators.h
  2. 4
      apt-pkg/contrib/fileutl.cc
  3. 16
      apt-pkg/contrib/mmap.cc
  4. 4
      apt-pkg/contrib/mmap.h
  5. 255
      apt-pkg/deb/deblistparser.cc
  6. 51
      apt-pkg/deb/deblistparser.h
  7. 32
      apt-pkg/pkgcache.cc
  8. 77
      apt-pkg/pkgcache.h
  9. 93
      apt-pkg/pkgcachegen.cc
  10. 21
      apt-pkg/pkgcachegen.h
  11. 19
      apt-pkg/tagfile.cc
  12. 14
      apt-pkg/version.cc

9
apt-pkg/cacheiterators.h

@ -1,6 +1,6 @@
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: cacheiterators.h,v 1.1 1998/07/02 02:58:12 jgg Exp $
// $Id: cacheiterators.h,v 1.2 1998/07/04 05:57:34 jgg Exp $
/* ######################################################################
Cache Iterators - Iterators for navigating the cache structure
@ -65,6 +65,7 @@ class pkgCache::PkgIterator
inline VerIterator CurrentVer() const;
inline DepIterator RevDependsList() const;
inline PrvIterator ProvidesList() const;
inline unsigned long Index() const {return Pkg - Owner->PkgP;};
OkState State() const;
// Constructors
@ -116,8 +117,9 @@ class pkgCache::VerIterator
inline PkgIterator ParentPkg() const {return PkgIterator(Owner,Owner.PkgP + Ver->ParentPkg);};
inline DepIterator DependsList() const;
inline PrvIterator ProvidesList() const;
inline unsigned long Index() const {return Ver - Owner.VerP;};
inline VerIterator(pkgCache &Owner,Version *Trg) : Ver(Trg), Owner(Owner)
inline VerIterator(pkgCache &Owner,Version *Trg = 0) : Ver(Trg), Owner(Owner)
{
if (Ver == 0)
Ver = Owner.VerP;
@ -161,6 +163,7 @@ class pkgCache::DepIterator
inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[Dep->ParentVer].ParentPkg);};
bool IsCritical();
inline bool Reverse() {return Type == DepRev;};
inline unsigned long Index() const {return Dep - Owner->DepP;};
inline DepIterator(pkgCache &Owner,Dependency *Trg,Version * = 0) :
Dep(Trg), Type(DepVer), Owner(&Owner)
@ -210,6 +213,7 @@ class pkgCache::PrvIterator
inline PkgIterator ParentPkg() {return PkgIterator(*Owner,Owner->PkgP + Prv->ParentPkg);};
inline VerIterator OwnerVer() {return VerIterator(*Owner,Owner->VerP + Prv->Version);};
inline PkgIterator OwnerPkg() {return PkgIterator(*Owner,Owner->PkgP + Owner->VerP[Prv->Version].ParentPkg);};
inline unsigned long Index() const {return Prv - Owner->ProvideP;};
inline PrvIterator(pkgCache &Owner,Provides *Trg,Version *) :
Prv(Trg), Type(PrvVer), Owner(&Owner)
@ -252,6 +256,7 @@ class pkgCache::PkgFileIterator
inline const char *FileName() const {return File->FileName == 0?0:Owner->StrP + File->FileName;};
inline const char *Version() const {return File->Version == 0?0:Owner->StrP + File->Version;};
inline const char *Distribution() const {return File->Distribution == 0?0:Owner->StrP + File->Distribution;};
inline unsigned long Index() const {return File - Owner->PkgFileP;};
bool IsOk();

4
apt-pkg/contrib/fileutl.cc

@ -1,6 +1,6 @@
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: fileutl.cc,v 1.1 1998/07/02 02:58:13 jgg Exp $
// $Id: fileutl.cc,v 1.2 1998/07/04 05:57:41 jgg Exp $
/* ######################################################################
File Utilities
@ -14,7 +14,7 @@
##################################################################### */
/*}}}*/
// Include Files /*{{{*/
#include <fileutl.h>
#include <pkglib/fileutl.h>
#include <pkglib/error.h>
#include <unistd.h>

16
apt-pkg/contrib/mmap.cc

@ -1,6 +1,6 @@
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: mmap.cc,v 1.1 1998/07/02 02:58:13 jgg Exp $
// $Id: mmap.cc,v 1.2 1998/07/04 05:57:42 jgg Exp $
/* ######################################################################
MMap Class - Provides 'real' mmap or a faked mmap using read().
@ -142,11 +142,14 @@ DynamicMMap::~DynamicMMap()
/*}}}*/
// DynamicMMap::RawAllocate - Allocate a raw chunk of unaligned space /*{{{*/
// ---------------------------------------------------------------------
/* */
unsigned long DynamicMMap::RawAllocate(unsigned long Size)
/* This allocates a block of memory aligned to the given size */
unsigned long DynamicMMap::RawAllocate(unsigned long Size,unsigned long Aln)
{
unsigned long Result = iSize;
iSize += Size;
if (Aln != 0)
Result += Aln - (iSize%Aln);
iSize = Result + Size;
// Just in case error check
if (Result > WorkSpace)
@ -154,7 +157,6 @@ unsigned long DynamicMMap::RawAllocate(unsigned long Size)
_error->Error("Dynamic MMap ran out of room");
return 0;
}
return Result;
}
/*}}}*/
@ -194,9 +196,9 @@ unsigned long DynamicMMap::Allocate(unsigned long ItemSize)
if (I->Count == 0)
{
I->Count = 20*1024/ItemSize;
I->Start = RawAllocate(I->Count*ItemSize);
I->Start = RawAllocate(I->Count*ItemSize,ItemSize);
}
I->Count--;
unsigned long Result = I->Start;
I->Start += ItemSize;

4
apt-pkg/contrib/mmap.h

@ -1,6 +1,6 @@
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: mmap.h,v 1.1 1998/07/02 02:58:13 jgg Exp $
// $Id: mmap.h,v 1.2 1998/07/04 05:57:43 jgg Exp $
/* ######################################################################
MMap Class - Provides 'real' mmap or a faked mmap using read().
@ -79,7 +79,7 @@ class DynamicMMap : public MMap
public:
// Allocation
unsigned long RawAllocate(unsigned long Size);
unsigned long RawAllocate(unsigned long Size,unsigned long Aln = 0);
unsigned long Allocate(unsigned long ItemSize);
unsigned long WriteString(const char *String,unsigned long Len = 0);
inline unsigned long WriteString(string S) {return WriteString(S.begin(),S.size());};

255
apt-pkg/deb/deblistparser.cc

@ -0,0 +1,255 @@
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: deblistparser.cc,v 1.1 1998/07/04 05:58:08 jgg Exp $
/* ######################################################################
Package Cache Generator - Generator for the cache structure.
This builds the cache structure from the abstract package list parser.
##################################################################### */
/*}}}*/
// Include Files /*{{{*/
#include <pkglib/deblistparser.h>
#include <pkglib/error.h>
#include <system.h>
/*}}}*/
// ListParser::debListParser - Constructor /*{{{*/
// ---------------------------------------------------------------------
/* */
debListParser::debListParser(File &File) : Tags(File)
{
Step();
}
/*}}}*/
// ListParser::FindTag - Find the tag and return a string /*{{{*/
// ---------------------------------------------------------------------
/* */
string debListParser::FindTag(const char *Tag)
{
const char *Start;
const char *Stop;
if (Section.Find(Tag,Start,Stop) == false)
return string();
return string(Start,Stop - Start);
}
/*}}}*/
// ListParser::UniqFindTagWrite - Find the tag and write a unq string /*{{{*/
// ---------------------------------------------------------------------
/* */
unsigned long debListParser::UniqFindTagWrite(const char *Tag)
{
const char *Start;
const char *Stop;
if (Section.Find(Tag,Start,Stop) == false)
return 0;
return WriteUniqString(Start,Stop - Start);
}
/*}}}*/
// ListParser::HandleFlag - Sets a flag variable based on a tag /*{{{*/
// ---------------------------------------------------------------------
/* This checks the tag for true/false yes/no etc */
bool debListParser::HandleFlag(const char *Tag,unsigned long &Flags,
unsigned long Flag)
{
const char *Start;
const char *Stop;
if (Section.Find(Tag,Start,Stop) == false)
return true;
int Set = 2;
if (strncasecmp(Start,"yes",Stop - Start) == 0)
Set = 1;
if (strncasecmp(Start,"true",Stop - Start) == 0)
Set = 1;
if (strncasecmp(Start,"no",Stop - Start) == 0)
Set = 0;
if (strncasecmp(Start,"false",Stop - Start) == 0)
Set = 0;
if (Set == 2)
{
_error->Warning("Unknown flag value");
return true;
}
if (Set == 0)
Flags &= ~Flag;
if (Set == 1)
Flags |= Flag;
return true;
}
/*}}}*/
// ListParser::Package - Return the package name /*{{{*/
// ---------------------------------------------------------------------
/* This is to return the name of the package this section describes */
string debListParser::Package()
{
string Result = FindTag("Package");
if (Result.empty() == true)
_error->Error("Encoutered a section with no Package: header");
return Result;
}
/*}}}*/
// ListParser::Version - Return the version string /*{{{*/
// ---------------------------------------------------------------------
/* This is to return the string describing the version in debian form,
epoch:upstream-release. If this returns the blank string then the
entry is assumed to only describe package properties */
string debListParser::Version()
{
return FindTag("Version");
}
/*}}}*/
// ListParser::NewPackage - Fill in the package structure /*{{{*/
// ---------------------------------------------------------------------
/* This is called when a new package structure is created. It must fill
in the static package information. */
bool debListParser::NewPackage(pkgCache::PkgIterator Pkg)
{
// Debian doesnt have anything, everything is condionally megered
return true;
}
/*}}}*/
// ListParser::NewVersion - Fill in the version structure /*{{{*/
// ---------------------------------------------------------------------
/* */
bool debListParser::NewVersion(pkgCache::VerIterator Ver)
{
return true;
}
/*}}}*/
// ListParser::UsePackage - Update a package structure /*{{{*/
// ---------------------------------------------------------------------
/* This is called to update the package with any new information
that might be found in the section */
bool debListParser::UsePackage(pkgCache::PkgIterator Pkg,
pkgCache::VerIterator Ver)
{
if (Pkg->Section == 0)
if ((Pkg->Section = UniqFindTagWrite("Section")) == 0)
return false;
if (HandleFlag("Essential",Pkg->Flags,pkgCache::Essential) == false)
return false;
if (HandleFlag("Immediate-Configure",Pkg->Flags,pkgCache::ImmediateConf) == false)
return false;
if (ParseStatus(Pkg,Ver) == false)
return false;
return true;
}
/*}}}*/
// ListParser::ParseStatus - Parse the status feild /*{{{*/
// ---------------------------------------------------------------------
/* Status lines are of the form,
Status: want flag status
want = unknown, install, hold, deinstall, purge
flag = ok, reinstreq, hold, hold-reinstreq
status = not-installed, unpacked, half-configured, uninstalled,
half-installed, config-files, post-inst-failed,
removal-failed, installed
Some of the above are obsolete (I think?) flag = hold-* and
status = post-inst-failed, removal-failed at least.
*/
bool debListParser::ParseStatus(pkgCache::PkgIterator Pkg,
pkgCache::VerIterator Ver)
{
const char *Start;
const char *Stop;
if (Section.Find("Status",Start,Stop) == false)
return true;
// Isolate the first word
const char *I = Start;
for(; I < Stop && *I != ' '; I++);
if (I >= Stop || *I != ' ')
return _error->Error("Malformed Status line");
// Process the want field
WordList WantList[] = {{"unknown",pkgCache::Unknown},
{"install",pkgCache::Install},
{"hold",pkgCache::Hold},
{"deinstall",pkgCache::DeInstall},
{"purge",pkgCache::Purge}};
if (GrabWord(string(Start,I-Start),WantList,
_count(WantList),Pkg->SelectedState) == false)
return _error->Error("Malformed 1st word in the Status line");
// Isloate the next word
I++;
Start = I;
for(; I < Stop && *I != ' '; I++);
if (I >= Stop || *I != ' ')
return _error->Error("Malformed status line, no 2nd word");
// Process the flag field
WordList FlagList[] = {{"ok",pkgCache::Ok},
{"reinstreq",pkgCache::ReInstReq},
{"hold",pkgCache::HoldInst},
{"hold-reinstreq",pkgCache::HoldReInstReq}};
if (GrabWord(string(Start,I-Start),FlagList,
_count(FlagList),Pkg->InstState) == false)
return _error->Error("Malformed 2nd word in the Status line");
// Isloate the last word
I++;
Start = I;
for(; I < Stop && *I != ' '; I++);
if (I != Stop)
return _error->Error("Malformed Status line, no 3rd word");
// Process the flag field
WordList StatusList[] = {{"not-installed",pkgCache::NotInstalled},
{"unpacked",pkgCache::UnPacked},
{"half-configured",pkgCache::HalfConfigured},
{"installed",pkgCache::Installed},
{"uninstalled",pkgCache::UnInstalled},
{"half-installed",pkgCache::HalfInstalled},
{"config-files",pkgCache::ConfigFiles},
{"post-inst-failed",pkgCache::HalfConfigured},
{"removal-failed",pkgCache::HalfInstalled}};
if (GrabWord(string(Start,I-Start),StatusList,
_count(StatusList),Pkg->CurrentState) == false)
return _error->Error("Malformed 3rd word in the Status line");
/* A Status line marks the package as indicating the current
version as well. Only if it is actually installed.. Otherwise
the interesting dpkg handling of the status file creates bogus
entries. */
if (!(Pkg->CurrentState == pkgCache::NotInstalled ||
Pkg->CurrentState == pkgCache::ConfigFiles))
{
if (Ver.end() == true)
_error->Warning("Encountered status field in a non-version description");
else
Pkg->CurrentVer = Ver.Index();
}
return true;
}
/*}}}*/
// ListParser::GrabWord - Matches a word and returns /*{{{*/
// ---------------------------------------------------------------------
/* Looks for a word in a list of words - for ParseStatus */
bool debListParser::GrabWord(string Word,WordList *List,int Count,
unsigned char &Out)
{
for (int C = 0; C != Count; C++)
{
if (strcasecmp(Word.c_str(),List[C].Str) == 0)
{
Out = List[C].Val;
return true;
}
}
return false;
}
/*}}}*/
// ListParser::Step - Move to the next section in the file /*{{{*/
// ---------------------------------------------------------------------
/* */
bool debListParser::Step()
{
return Tags.Step(Section);
}
/*}}}*/

51
apt-pkg/deb/deblistparser.h

@ -0,0 +1,51 @@
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: deblistparser.h,v 1.1 1998/07/04 05:58:08 jgg Exp $
/* ######################################################################
Debian Package List Parser - This implements the abstract parser
interface for Debian package files
##################################################################### */
/*}}}*/
// Header section: pkglib
#ifndef PKGLIB_DEBLISTPARSER_H
#define PKGLIB_DEBLISTPARSER_H
#include <pkglib/pkgcachegen.h>
#include <pkglib/tagfile.h>
class debListParser : public pkgCacheGenerator::ListParser
{
pkgTagFile Tags;
pkgTagSection Section;
// Parser Helper
struct WordList
{
char *Str;
unsigned char Val;
};
string FindTag(const char *Tag);
unsigned long UniqFindTagWrite(const char *Tag);
bool HandleFlag(const char *Tag,unsigned long &Flags,unsigned long Flag);
bool ParseStatus(pkgCache::PkgIterator Pkg,pkgCache::VerIterator Ver);
bool GrabWord(string Word,WordList *List,int Count,unsigned char &Out);
public:
// These all operate against the current section
virtual string Package();
virtual string Version();
virtual bool NewVersion(pkgCache::VerIterator Ver);
virtual bool NewPackage(pkgCache::PkgIterator Pkg);
virtual bool UsePackage(pkgCache::PkgIterator Pkg,
pkgCache::VerIterator Ver);
virtual bool Step();
debListParser(File &File);
};
#endif

32
apt-pkg/pkgcache.cc

@ -1,6 +1,6 @@
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: pkgcache.cc,v 1.1 1998/07/02 02:58:12 jgg Exp $
// $Id: pkgcache.cc,v 1.2 1998/07/04 05:57:35 jgg Exp $
/* ######################################################################
Package Cache - Accessor code for the cache
@ -159,7 +159,12 @@ pkgCache::PkgIterator pkgCache::FindPkg(string Name)
}
/*}}}*/
// Cache::PkgIterator - operator ++ - Postfix incr /*{{{*/
// Bases for iterator classes /*{{{*/
void pkgCache::VerIterator::_dummy() {}
void pkgCache::DepIterator::_dummy() {}
void pkgCache::PrvIterator::_dummy() {}
/*}}}*/
// PkgIterator::operator ++ - Postfix incr /*{{{*/
// ---------------------------------------------------------------------
/* This will advance to the next logical package in the hash table. */
void pkgCache::PkgIterator::operator ++(int)
@ -176,23 +181,18 @@ void pkgCache::PkgIterator::operator ++(int)
}
};
/*}}}*/
// Bases for iterator classes /*{{{*/
void pkgCache::VerIterator::_dummy() {}
void pkgCache::DepIterator::_dummy() {}
void pkgCache::PrvIterator::_dummy() {}
/*}}}*/
// PkgIterator::State - Check the State of the package /*{{{*/
// ---------------------------------------------------------------------
/* By this we mean if it is either cleanly installed or cleanly removed. */
pkgCache::PkgIterator::OkState pkgCache::PkgIterator::State() const
{
if (Pkg->CurrentState == pkgSTATE_UnPacked ||
Pkg->CurrentState == pkgSTATE_HalfConfigured)
if (Pkg->CurrentState == UnPacked ||
Pkg->CurrentState == HalfConfigured)
return NeedsConfigure;
if (Pkg->CurrentState == pkgSTATE_UnInstalled ||
Pkg->CurrentState == pkgSTATE_HalfInstalled ||
Pkg->InstState != pkgSTATE_Ok)
if (Pkg->CurrentState == UnInstalled ||
Pkg->CurrentState == HalfInstalled ||
Pkg->InstState != Ok)
return NeedsUnpack;
return NeedsNothing;
@ -204,8 +204,8 @@ pkgCache::PkgIterator::OkState pkgCache::PkgIterator::State() const
conflicts. */
bool pkgCache::DepIterator::IsCritical()
{
if (Dep->Type == pkgDEP_Conflicts || Dep->Type == pkgDEP_Depends ||
Dep->Type == pkgDEP_PreDepends)
if (Dep->Type == Conflicts || Dep->Type == Depends ||
Dep->Type == PreDepends)
return true;
return false;
}
@ -280,7 +280,7 @@ pkgCache::Version **pkgCache::DepIterator::AllTargets()
if (pkgCheckDep(TargetVer(),I.VerStr(),Dep->CompareOp) == false)
continue;
if (Dep->Type == pkgDEP_Conflicts && ParentPkg() == I.ParentPkg())
if (Dep->Type == Conflicts && ParentPkg() == I.ParentPkg())
continue;
Size++;
@ -294,7 +294,7 @@ pkgCache::Version **pkgCache::DepIterator::AllTargets()
if (pkgCheckDep(TargetVer(),I.ProvideVersion(),Dep->CompareOp) == false)
continue;
if (Dep->Type == pkgDEP_Conflicts && ParentPkg() == I.OwnerPkg())
if (Dep->Type == Conflicts && ParentPkg() == I.OwnerPkg())
continue;
Size++;

77
apt-pkg/pkgcache.h

@ -1,6 +1,6 @@
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: pkgcache.h,v 1.1 1998/07/02 02:58:12 jgg Exp $
// $Id: pkgcache.h,v 1.2 1998/07/04 05:57:36 jgg Exp $
/* ######################################################################
Cache - Structure definitions for the cache file
@ -24,62 +24,6 @@
#include <time.h>
#include <pkglib/mmap.h>
// Definitions for Depends::Type
#define pkgDEP_Depends 1
#define pkgDEP_PreDepends 2
#define pkgDEP_Suggests 3
#define pkgDEP_Recommends 4
#define pkgDEP_Conflicts 5
#define pkgDEP_Replaces 6
// Definitions for Version::Priority
#define pkgPRIO_Important 1
#define pkgPRIO_Required 2
#define pkgPRIO_Standard 3
#define pkgPRIO_Optional 4
#define pkgPRIO_Extra 5
// Definitions for Package::SelectedState
#define pkgSTATE_Unkown 0
#define pkgSTATE_Install 1
#define pkgSTATE_Hold 2
#define pkgSTATE_DeInstall 3
#define pkgSTATE_Purge 4
// Definitions for Package::Flags
#define pkgFLAG_Auto (1 << 0)
#define pkgFLAG_New (1 << 1)
#define pkgFLAG_Obsolete (1 << 2)
#define pkgFLAG_Essential (1 << 3)
#define pkgFLAG_ImmediateConf (1 << 4)
// Definitions for Package::InstState
#define pkgSTATE_Ok 0
#define pkgSTATE_ReInstReq 1
#define pkgSTATE_Hold 2
#define pkgSTATE_HoldReInstReq 3
// Definitions for Package::CurrentState
#define pkgSTATE_NotInstalled 0
#define pkgSTATE_UnPacked 1
#define pkgSTATE_HalfConfigured 2
#define pkgSTATE_UnInstalled 3
#define pkgSTATE_HalfInstalled 4
#define pkgSTATE_ConfigFiles 5
#define pkgSTATE_Installed 6
// Definitions for PackageFile::Flags
#define pkgFLAG_NotSource (1 << 0)
// Definitions for Dependency::CompareOp
#define pkgOP_OR 0x10
#define pkgOP_LESSEQ 0x1
#define pkgOP_GREATEREQ 0x2
#define pkgOP_LESS 0x3
#define pkgOP_GREATER 0x4
#define pkgOP_EQUALS 0x5
#define pkgOP_NOTEQUALS 0x6
class pkgCache
{
public:
@ -103,6 +47,21 @@ class pkgCache
friend DepIterator;
friend PrvIterator;
friend PkgFileIterator;
// These are all the constants used in the cache structures
enum DepType {Depends=1,PreDepends=2,Suggests=3,Recommends=4,
Conflicts=5,Replaces=6};
enum VerPriority {Important=1,Required=2,Standard=3,Optional=5,Extra=5};
enum PkgSelectedState {Unknown=0,Install=1,Hold=2,DeInstall=3,Purge=4};
enum PkgFlags {Auto=(1<<0),New=(1<<1),Obsolete=(1<<2),Essential=(1<<3),
ImmediateConf=(1<<4)};
enum PkgInstState {Ok=0,ReInstReq=1,HoldInst=2,HoldReInstReq=3};
enum PkgCurrentState {NotInstalled=0,UnPacked=1,HalfConfigured=2,
UnInstalled=3,HalfInstalled=4,ConfigFiles=5,
Installed=6};
enum PkgFFlags {NotSource=(1<<0)};
enum DepCompareOp {Or=0x10,LessEq=0x1,GreaterEq=0x2,Less=0x3,
Greater=0x4,Equals=0x5,NotEquals=0x6};
protected:
@ -204,7 +163,7 @@ struct pkgCache::Package
unsigned char CurrentState; // State
unsigned short ID;
unsigned short Flags;
unsigned long Flags;
};
struct pkgCache::PackageFile
@ -218,7 +177,7 @@ struct pkgCache::PackageFile
// Linked list
unsigned long NextFile; // PackageFile
unsigned short ID;
unsigned short Flags;
unsigned long Flags;
time_t mtime; // Modification time for the file
};

93
apt-pkg/pkgcachegen.cc

@ -1,6 +1,6 @@
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: pkgcachegen.cc,v 1.1 1998/07/02 02:58:12 jgg Exp $
// $Id: pkgcachegen.cc,v 1.2 1998/07/04 05:57:37 jgg Exp $
/* ######################################################################
Package Cache Generator - Generator for the cache structure.
@ -58,13 +58,12 @@ pkgCacheGenerator::~pkgCacheGenerator()
bool pkgCacheGenerator::MergeList(ListParser &List)
{
List.Owner = this;
do
{
// Get a pointer to the package structure
string Package = List.Package();
pkgCache::PkgIterator Pkg = Cache.FindPkg(Package);
if (Pkg.end() == false)
if (Pkg.end() == true)
{
if (NewPackage(Pkg,Package) == false)
return false;
@ -72,17 +71,22 @@ bool pkgCacheGenerator::MergeList(ListParser &List)
if (List.NewPackage(Pkg) == false)
return false;
}
if (List.UsePackage(Pkg) == false)
return false;
/* Get a pointer to the version structure. We know the list is sorted
so we use that fact in the search. Insertion of new versions is
done with correct sorting */
string Version = List.Version();
if (Version.empty() == true)
{
if (List.UsePackage(Pkg,pkgCache::VerIterator(Cache)) == false)
return false;
continue;
}
pkgCache::VerIterator Ver = Pkg.VersionList();
unsigned long *Last = &Pkg->VersionList;
int Res;
for (; Ver.end() == false; Ver++, Last = &Ver->NextVer)
for (; Ver.end() == false; Last = &Ver->NextVer, Ver++)
{
Res = pkgVersionCompare(Version.begin(),Version.end(),Ver.VerStr(),
Ver.VerStr() + strlen(Ver.VerStr()));
@ -94,6 +98,9 @@ bool pkgCacheGenerator::MergeList(ListParser &List)
saw it */
if (Res == 0)
{
if (List.UsePackage(Pkg,Ver) == false)
return false;
if (NewFileVer(Ver,List) == false)
return false;
@ -101,10 +108,14 @@ bool pkgCacheGenerator::MergeList(ListParser &List)
}
// Add a new version
*Last = NewVersion(Ver,*Last);
*Last = NewVersion(Ver,Version,*Last);
Ver->ParentPkg = Pkg.Index();
if (List.NewVersion(Ver) == false)
return false;
if (List.UsePackage(Pkg,Ver) == false)
return false;
if (NewFileVer(Ver,List) == false)
return false;
}
@ -116,17 +127,17 @@ bool pkgCacheGenerator::MergeList(ListParser &List)
// CacheGenerator::NewPackage - Add a new package /*{{{*/
// ---------------------------------------------------------------------
/* This creates a new package structure and adds it to the hash table */
bool pkgCacheGenerator::NewPackage(pkgCache::PkgIterator Pkg,string Name)
bool pkgCacheGenerator::NewPackage(pkgCache::PkgIterator &Pkg,string Name)
{
// Get a structure
unsigned long Package = Map.Allocate(sizeof(pkgCache::Package));
if (Package == 0)
return false;
Pkg = pkgCache::PkgIterator(Cache,Cache.PackageP + Package);
Pkg = pkgCache::PkgIterator(Cache,Cache.PkgP + Package);
// Insert it into the hash table
unsigned long Hash = Map.Hash(Name);
unsigned long Hash = Cache.Hash(Name);
Pkg->NextPackage = Cache.HeaderP->HashTable[Hash];
Cache.HeaderP->HashTable[Hash] = Package;
@ -142,17 +153,34 @@ bool pkgCacheGenerator::NewPackage(pkgCache::PkgIterator Pkg,string Name)
// CacheGenerator::NewFileVer - Create a new File<->Version association /*{{{*/
// ---------------------------------------------------------------------
/* */
bool pkgCacheGenerator::NewFileVer(pkgCache::VerIterator Ver,
bool pkgCacheGenerator::NewFileVer(pkgCache::VerIterator &Ver,
ListParser &List)
{
return true;
}
/*}}}*/
// CacheGenerator::NewVersion - Create a new Version /*{{{*/
// ---------------------------------------------------------------------
/* */
/* This puts a version structure in the linked list */
unsigned long pkgCacheGenerator::NewVersion(pkgCache::VerIterator &Ver,
string VerStr,
unsigned long Next)
{
// Get a structure
unsigned long Version = Map.Allocate(sizeof(pkgCache::Version));
if (Version == 0)
return false;
// Fill it in
Ver = pkgCache::VerIterator(Cache,Cache.VerP + Version);
Ver->File = CurrentFile - Cache.PkgFileP;
Ver->NextVer = Next;
Ver->ID = Cache.HeaderP->VersionCount++;
Ver->VerStr = Map.WriteString(VerStr);
if (Ver->VerStr == 0)
return false;
return true;
}
/*}}}*/
// CacheGenerator::SelectFile - Select the current file being parsed /*{{{*/
@ -182,3 +210,44 @@ bool pkgCacheGenerator::SelectFile(string File,unsigned long Flags)
return false;
}
/*}}}*/
// CacheGenerator::WriteUniqueString - Insert a unique string /*{{{*/
// ---------------------------------------------------------------------
/* 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,
unsigned int Size)
{
// Search for an insertion point
pkgCache::StringItem *I = Cache.StringItemP + Cache.HeaderP->StringList;
int Res = 1;
unsigned long *Last = &Cache.HeaderP->StringList;
for (; I != Cache.StringItemP; Last = &I->NextItem,
I = Cache.StringItemP + I->NextItem)
{
Res = strncmp(Cache.StrP + I->String,S,Size);
if (Res == 0 && *(Cache.StrP + I->String + Size) != 0)
Res = 1;
if (Res >= 0)
break;
}
// Match
if (Res == 0)
return I - Cache.StringItemP;
// Get a structure
unsigned long Item = Map.Allocate(sizeof(pkgCache::StringItem));
if (Item == 0)
return false;
// Fill in the structure
pkgCache::StringItem *ItemP = Cache.StringItemP + Item;
ItemP->NextItem = I - Cache.StringItemP;
*Last = Item;
ItemP->String = Map.WriteString(S,Size);
if (ItemP->String == 0)
return false;
return true;
}
/*}}}*/

21
apt-pkg/pkgcachegen.h

@ -1,6 +1,6 @@
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: pkgcachegen.h,v 1.1 1998/07/02 02:58:13 jgg Exp $
// $Id: pkgcachegen.h,v 1.2 1998/07/04 05:57:38 jgg Exp $
/* ######################################################################
Package Cache Generator - Generator for the cache structure.
@ -29,10 +29,13 @@ class pkgCacheGenerator
string PkgFileName;
pkgCache::PackageFile *CurrentFile;
bool NewPackage(pkgCache::PkgIterator Pkg,string Pkg);
bool NewFileVer(pkgCache::VerIterator Ver,ListParser &List);
unsigned long NewVersion(pkgCache::VerIterator &Ver,unsigned long Next);
bool NewPackage(pkgCache::PkgIterator &Pkg,string Pkg);
bool NewFileVer(pkgCache::VerIterator &Ver,ListParser &List);
unsigned long NewVersion(pkgCache::VerIterator &Ver,string VerStr,unsigned long Next);
unsigned long WriteUniqString(const char *S,unsigned int Size);
inline unsigned long WriteUniqString(string S) {return WriteUniqString(S);};
public:
// This is the abstract package list parser class.
@ -43,9 +46,11 @@ class pkgCacheGenerator
protected:
inline unsigned long WriteUniqString(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(string S) {return Owner->Map.WriteString(S);};
inline unsigned long WriteString(const char *S,unsigned int Size) {return Owner->Map.WriteString(S,Size);};
public:
// These all operate against the current section
@ -53,9 +58,11 @@ class pkgCacheGenerator
virtual string Version() = 0;
virtual bool NewVersion(pkgCache::VerIterator Ver) = 0;
virtual bool NewPackage(pkgCache::PkgIterator Pkg) = 0;
virtual bool UsePackage(pkgCache::PkgIterator Pkg) = 0;
virtual bool UsePackage(pkgCache::PkgIterator Pkg,
pkgCache::VerIterator Ver) = 0;
virtual bool Step() = 0;
virtual ~ListParser() {};
};
friend ListParser;

19
apt-pkg/tagfile.cc

@ -1,6 +1,6 @@
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: tagfile.cc,v 1.1 1998/07/02 02:58:13 jgg Exp $
// $Id: tagfile.cc,v 1.2 1998/07/04 05:57:39 jgg Exp $
/* ######################################################################
Fast scanner for RFC-822 type header information
@ -147,18 +147,31 @@ bool pkgTagSection::Find(const char *Tag,const char *&Start,
/*}}}*/
#include <pkglib/pkgcachegen.h>
#include <pkglib/deblistparser.h>
int main(int argc,char *argv[])
{
{
File F(argv[1],File::ReadOnly);
pkgTagFile Test(F);
File CacheF("./cache",File::WriteEmpty);
DynamicMMap Map(CacheF,MMap::Public);
pkgCacheGenerator Gen(Map);
Gen.SelectFile("tet");
Gen.SelectFile(argv[1]);
debListParser Parser(F);
Gen.MergeList(Parser);
}
{
File CacheF("./cache",File::WriteExists);
MMap Map(CacheF,MMap::Public);
pkgCache Cache(Map);
for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; I++)
{
cout << "Package: " << I.Name() << endl;
}
}
#if 0
pkgTagSection I;
while (Test.Step(I) == true)

14
apt-pkg/version.cc

@ -1,6 +1,6 @@
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: version.cc,v 1.1 1998/07/02 02:58:13 jgg Exp $
// $Id: version.cc,v 1.2 1998/07/04 05:57:40 jgg Exp $
/* ######################################################################
Version - Version string
@ -212,32 +212,32 @@ bool pkgCheckDep(const char *DepVer,const char *PkgVer,int Op)
int Res = pkgVersionCompare(PkgVer,DepVer);
switch (Op & 0x0F)
{
case pkgOP_LESSEQ:
case pkgCache::LessEq:
if (Res <= 0)
return true;
break;
case pkgOP_GREATEREQ:
case pkgCache::GreaterEq:
if (Res >= 0)
return true;
break;
case pkgOP_LESS:
case pkgCache::Less:
if (Res < 0)
return true;
break;
case pkgOP_GREATER:
case pkgCache::Greater:
if (Res > 0)
return true;
break;
case pkgOP_EQUALS:
case pkgCache::Equals:
if (Res == 0)
return true;
break;
case pkgOP_NOTEQUALS:
case pkgCache::NotEquals:
if (Res != 0)
return true;
break;

Loading…
Cancel
Save