// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
-// $Id: cacheiterators.h,v 1.2 1998/07/04 05:57:34 jgg Exp $
+// $Id: cacheiterators.h,v 1.3 1998/07/05 05:33:52 jgg Exp $
/* ######################################################################
Cache Iterators - Iterators for navigating the cache structure
inline operator Version const *() const {return Ver == Owner.VerP?0:Ver;};
inline const char *VerStr() const {return Ver->VerStr == 0?0:Owner.StrP + Ver->VerStr;};
inline const char *Section() const {return Ver->Section == 0?0:Owner.StrP + Ver->Section;};
- inline PkgFileIterator File() const;
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 VerFileIterator FileList() const;
inline VerIterator(pkgCache &Owner,Version *Trg = 0) : Ver(Trg), Owner(Owner)
{
inline PkgFileIterator(pkgCache &Owner,PackageFile *Trg) : Owner(&Owner), File(Trg) {};
};
+// Version File
+class pkgCache::VerFileIterator
+{
+ pkgCache *Owner;
+ VerFile *FileP;
+
+ public:
+
+ // Iteration
+ void operator ++(int) {if (FileP != Owner->VerFileP) FileP = Owner->VerFileP + FileP->NextFile;};
+ inline void operator ++() {operator ++(0);};
+ inline bool end() const {return FileP == Owner->VerFileP?true:false;};
+
+ // Comparison
+ inline bool operator ==(const VerFileIterator &B) const {return FileP == B.FileP;};
+ inline bool operator !=(const VerFileIterator &B) const {return FileP != B.FileP;};
+
+ // Accessors
+ inline VerFile *operator ->() {return FileP;};
+ inline VerFile const *operator ->() const {return FileP;};
+ inline VerFile const &operator *() const {return *FileP;};
+ inline operator VerFile *() {return FileP == Owner->VerFileP?0:FileP;};
+ inline operator VerFile const *() const {return FileP == Owner->VerFileP?0:FileP;};
+
+ inline PkgFileIterator File() const {return PkgFileIterator(*Owner,FileP->File + Owner->PkgFileP);};
+ inline unsigned long Index() const {return FileP - Owner->VerFileP;};
+
+ inline VerFileIterator(pkgCache &Owner,VerFile *Trg) : Owner(&Owner), FileP(Trg) {};
+};
+
// Inlined Begin functions cant be in the class because of order problems
inline pkgCache::VerIterator pkgCache::PkgIterator::VersionList() const
{return VerIterator(*Owner,Owner->VerP + Pkg->VersionList);};
{return PrvIterator(Owner,Owner.ProvideP + Ver->ProvidesList,Ver);};
inline pkgCache::DepIterator pkgCache::VerIterator::DependsList() const
{return DepIterator(Owner,Owner.DepP + Ver->DependsList,Ver);};
-inline pkgCache::PkgFileIterator pkgCache::VerIterator::File() const
- {return PkgFileIterator(Owner,Owner.PkgFileP + Ver->File);};
+inline pkgCache::VerFileIterator pkgCache::VerIterator::FileList() const
+ {return VerFileIterator(Owner,Owner.VerFileP + Ver->FileList);};
#endif
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
-// $Id: deblistparser.cc,v 1.2 1998/07/04 22:32:17 jgg Exp $
+// $Id: deblistparser.cc,v 1.3 1998/07/05 05:34:00 jgg Exp $
/* ######################################################################
Package Cache Generator - Generator for the cache structure.
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 /*{{{*/
// ---------------------------------------------------------------------
/* */
_count(PrioList),Ver->Priority) == false)
return _error->Error("Malformed Priority line");
}
+
+ if (ParseDepends(Ver,"Depends",pkgCache::Depends) == false)
+ return false;
+ if (ParseDepends(Ver,"PreDepends",pkgCache::PreDepends) == false)
+ return false;
+ if (ParseDepends(Ver,"Suggests",pkgCache::Suggests) == false)
+ return false;
+ if (ParseDepends(Ver,"Recommends",pkgCache::Recommends) == false)
+ return false;
+ if (ParseDepends(Ver,"Conflicts",pkgCache::Conflicts) == false)
+ return false;
+ if (ParseDepends(Ver,"Replaces",pkgCache::Depends) == false)
+ return false;
+
+ if (ParseProvides(Ver) == false)
+ return false;
return true;
}
return true;
}
/*}}}*/
-// ListParser::ParseStatus - Parse the status feild /*{{{*/
+// ListParser::ParseStatus - Parse the status field /*{{{*/
// ---------------------------------------------------------------------
/* Status lines are of the form,
Status: want flag status
Pkg->CurrentVer = Ver.Index();
}
+ return true;
+}
+ /*}}}*/
+// ListParser::ParseDepends - Parse a dependency element /*{{{*/
+// ---------------------------------------------------------------------
+/* This parses the dependency elements out of a standard string in place,
+ bit by bit. */
+const char *debListParser::ParseDepends(const char *Start,const char *Stop,
+ string &Package,string &Ver,
+ unsigned int &Op)
+{
+ // Strip off leading space
+ for (;Start != Stop && isspace(*Start) != 0; Start++);
+
+ // Parse off the package name
+ const char *I = Start;
+ for (;I != Stop && isspace(*I) == 0 && *I != '(' && *I != ')' &&
+ *I != ',' && *I != '|'; I++);
+
+ // Malformed, no '('
+ if (I != Stop && *I == ')')
+ return 0;
+
+ if (I == Start)
+ return 0;
+
+ // Stash the package name
+ Package.assign(Start,I - Start);
+
+ // Skip white space to the '('
+ for (;I != Stop && isspace(*I) != 0 ; I++);
+
+ // Parse a version
+ if (I != Stop && *I == '(')
+ {
+ // Skip the '('
+ for (I++; I != Stop && isspace(*I) != 0 ; I++);
+ if (I + 3 >= Stop)
+ return 0;
+
+ // Determine the operator
+ switch (*I)
+ {
+ case '<':
+ I++;
+ if (*I == '=')
+ {
+ I++;
+ Op = pkgCache::LessEq;
+ break;
+ }
+
+ if (*I == '<')
+ {
+ I++;
+ Op = pkgCache::Less;
+ break;
+ }
+
+ // < is the same as <= and << is really Cs < for some reason
+ Op = pkgCache::LessEq;
+ break;
+
+ case '>':
+ I++;
+ if (*I == '=')
+ {
+ I++;
+ Op = pkgCache::GreaterEq;
+ break;
+ }
+
+ if (*I == '>')
+ {
+ I++;
+ Op = pkgCache::Greater;
+ break;
+ }
+
+ // > is the same as >= and >> is really Cs > for some reason
+ Op = pkgCache::GreaterEq;
+ break;
+
+ case '=':
+ Op = pkgCache::Equals;
+ I++;
+ break;
+
+ // HACK around bad package definitions
+ default:
+ Op = pkgCache::Equals;
+ break;
+ }
+
+ // Skip whitespace
+ for (;I != Stop && isspace(*I) != 0; I++);
+ Start = I;
+ for (;I != Stop && *I != ')'; I++);
+ if (I == Stop || Start == I)
+ return 0;
+
+ Ver = string(Start,I-Start);
+ I++;
+ }
+ else
+ {
+ Ver = string();
+ Op = pkgCache::NoOp;
+ }
+
+ // Skip whitespace
+ for (;I != Stop && isspace(*I) != 0; I++);
+ if (I != Stop && *I == '|')
+ Op |= pkgCache::Or;
+
+ if (I == Stop || *I == ',' || *I == '|')
+ {
+ if (I != Stop)
+ for (I++; I != Stop && isspace(*I) != 0; I++);
+ return I;
+ }
+
+ return 0;
+}
+ /*}}}*/
+// ListParser::ParseDepends - Parse a dependency list /*{{{*/
+// ---------------------------------------------------------------------
+/* This is the higher level depends parser. It takes a tag and generates
+ a complete depends tree for the given version. */
+bool debListParser::ParseDepends(pkgCache::VerIterator Ver,
+ const char *Tag,unsigned int Type)
+{
+ const char *Start;
+ const char *Stop;
+ if (Section.Find(Tag,Start,Stop) == false)
+ return true;
+
+ string Package;
+ string Version;
+ unsigned int Op;
+
+ while ((Start = ParseDepends(Start,Stop,Package,Version,Op)) != Stop)
+ {
+ if (Start == 0)
+ return _error->Error("Problem parsing dependency %s",Tag);
+
+ if (NewDepends(Ver,Package,Version,Op,Type) == false)
+ return false;
+ }
+ return true;
+}
+ /*}}}*/
+// ListParser::ParseProvides - Parse the provides list /*{{{*/
+// ---------------------------------------------------------------------
+/* */
+bool debListParser::ParseProvides(pkgCache::VerIterator Ver)
+{
+ const char *Start;
+ const char *Stop;
+ if (Section.Find("Provides",Start,Stop) == false)
+ return true;
+
+ string Package;
+ string Version;
+ unsigned int Op;
+
+ while (1)
+ {
+ Start = ParseDepends(Start,Stop,Package,Version,Op);
+ if (Start == 0)
+ return _error->Error("Problem parsing Provides line");
+ if (Op != pkgCache::NoOp)
+ return _error->Error("Malformed provides line");
+
+ if (NewProvides(Ver,Package,Version) == false)
+ return false;
+
+ if (Start == Stop)
+ break;
+ }
+
return true;
}
/*}}}*/
/* This has to be carefull to only process the correct architecture */
bool debListParser::Step()
{
+ iOffset = Tags.Offset();
while (Tags.Step(Section) == true)
{
/* See if this is the correct Architecture, if it isnt then we
if (strncmp(Start,"all",Stop - Start) == 0 &&
3 == (unsigned)(Stop - Start))
return true;
+
+ iOffset = Tags.Offset();
}
return false;
}
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
-// $Id: deblistparser.h,v 1.2 1998/07/04 22:32:18 jgg Exp $
+// $Id: deblistparser.h,v 1.3 1998/07/05 05:34:01 jgg Exp $
/* ######################################################################
Debian Package List Parser - This implements the abstract parser
{
pkgTagFile Tags;
pkgTagSection Section;
+ unsigned long iOffset;
// Parser Helper
struct WordList
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);
+ const char *ParseDepends(const char *Start,const char *Stop,
+ string &Package,string &Ver,unsigned int &Op);
+ bool ParseDepends(pkgCache::VerIterator Ver,const char *Tag,
+ unsigned int Type);
+ bool ParseProvides(pkgCache::VerIterator Ver);
bool GrabWord(string Word,WordList *List,int Count,unsigned char &Out);
public:
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 unsigned long Offset() {return iOffset;};
+ virtual unsigned long Size() {return Section.size();};
virtual bool Step();
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
-// $Id: pkgcache.cc,v 1.3 1998/07/04 22:32:11 jgg Exp $
+// $Id: pkgcache.cc,v 1.4 1998/07/05 05:33:53 jgg Exp $
/* ######################################################################
Package Cache - Accessor code for the cache
VersionSz = sizeof(pkgCache::Version);
DependencySz = sizeof(pkgCache::Dependency);
ProvidesSz = sizeof(pkgCache::Provides);
-
+ VerFileSz = sizeof(pkgCache::VerFile);
+
PackageCount = 0;
VersionCount = 0;
DependsCount = 0;
PackageSz == Against.PackageSz &&
PackageFileSz == Against.PackageFileSz &&
VersionSz == Against.VersionSz &&
- DependencySz == Against.DependencySz &&
+ DependencySz == Against.DependencySz &&
+ VerFileSz == Against.VerFileSz &&
ProvidesSz == Against.ProvidesSz)
return true;
return false;
// Apply the typecasts.
HeaderP = (Header *)Map.Data();
PkgP = (Package *)Map.Data();
+ VerFileP = (VerFile *)Map.Data();
PkgFileP = (PackageFile *)Map.Data();
VerP = (Version *)Map.Data();
ProvideP = (Provides *)Map.Data();
StringItemP = (StringItem *)Map.Data();
StrP = (char *)Map.Data();
- cout << "Size is " << Map.Size() << endl;
if (Map.Size() == 0)
return false;
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
-// $Id: pkgcache.h,v 1.3 1998/07/04 22:32:12 jgg Exp $
+// $Id: pkgcache.h,v 1.4 1998/07/05 05:33:55 jgg Exp $
/* ######################################################################
Cache - Structure definitions for the cache file
struct Provides;
struct Dependency;
struct StringItem;
+ struct VerFile;
// Iterators
class PkgIterator;
class DepIterator;
class PrvIterator;
class PkgFileIterator;
+ class VerFileIterator;
friend PkgIterator;
friend VerIterator;
friend DepIterator;
friend PrvIterator;
friend PkgFileIterator;
-
+ friend VerFileIterator;
+
// These are all the constants used in the cache structures
enum DepType {Depends=1,PreDepends=2,Suggests=3,Recommends=4,
Conflicts=5,Replaces=6};
UnInstalled=3,HalfInstalled=4,ConfigFiles=5,
Installed=6};
enum PkgFFlags {NotSource=(1<<0)};
- enum DepCompareOp {Or=0x10,LessEq=0x1,GreaterEq=0x2,Less=0x3,
+ enum DepCompareOp {Or=0x10,NoOp=0,LessEq=0x1,GreaterEq=0x2,Less=0x3,
Greater=0x4,Equals=0x5,NotEquals=0x6};
protected:
// Pointers to the arrays of items
Header *HeaderP;
Package *PkgP;
+ VerFile *VerFileP;
PackageFile *PkgFileP;
Version *VerP;
Provides *ProvideP;
Dependency *DepP;
StringItem *StringItemP;
char *StrP;
-
+
virtual bool ReMap();
inline bool Sync() {return Map.Sync();};
unsigned short VersionSz;
unsigned short DependencySz;
unsigned short ProvidesSz;
-
+ unsigned short VerFileSz;
+
// Structure counts
unsigned long PackageCount;
unsigned long VersionCount;
/* Allocation pools, there should be one of these for each structure
excluding the header */
- DynamicMMap::Pool Pools[6];
+ DynamicMMap::Pool Pools[7];
// Rapid package name lookup
unsigned long HashTable[512];
time_t mtime; // Modification time for the file
};
+struct pkgCache::VerFile
+{
+ unsigned long File; // PackageFile
+ unsigned long NextFile; // PkgVerFile
+ unsigned long Offset;
+ unsigned short Size;
+};
+
struct pkgCache::Version
{
unsigned long VerStr; // Stringtable
- unsigned long File; // PackageFile
unsigned long Section; // StringTable (StringItem)
// Lists
+ unsigned long FileList; // VerFile
unsigned long NextVer; // Version
unsigned long DependsList; // Dependency
unsigned long ParentPkg; // Package
unsigned long ProvidesList; // Provides
- unsigned long Offset;
unsigned long Size;
unsigned long InstalledSize;
unsigned short ID;
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
-// $Id: pkgcachegen.cc,v 1.3 1998/07/04 22:32:13 jgg Exp $
+// $Id: pkgcachegen.cc,v 1.4 1998/07/05 05:33:56 jgg Exp $
/* ######################################################################
Package Cache Generator - Generator for the cache structure.
{
if (NewPackage(Pkg,Package) == false)
return false;
-
- if (List.NewPackage(Pkg) == false)
- return false;
}
/* Get a pointer to the version structure. We know the list is sorted
bool pkgCacheGenerator::NewFileVer(pkgCache::VerIterator &Ver,
ListParser &List)
{
+ // Get a structure
+ unsigned long VerFile = Map.Allocate(sizeof(pkgCache::VerFile));
+ if (VerFile == 0)
+ return 0;
+
+ pkgCache::VerFileIterator VF(Cache,Cache.VerFileP + VerFile);
+ VF->File = CurrentFile - Cache.PkgFileP;
+ VF->NextFile = Ver->FileList;
+ Ver->FileList = VF.Index();
+ VF->Offset = List.Offset();
+ VF->Size = List.Size();
+
return true;
}
/*}}}*/
// 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);
return Version;
}
/*}}}*/
+// ListParser::NewDepends - Create a dependency element /*{{{*/
+// ---------------------------------------------------------------------
+/* This creates a dependency element in the tree. It is linked to the
+ version and to the package that it is pointing to. */
+bool pkgCacheGenerator::ListParser::NewDepends(pkgCache::VerIterator Ver,
+ string Package,string Version,
+ unsigned int Op,
+ unsigned int Type)
+{
+ pkgCache &Cache = Owner->Cache;
+
+ // Get a structure
+ unsigned long Dependency = Owner->Map.Allocate(sizeof(pkgCache::Dependency));
+ if (Dependency == 0)
+ return false;
+
+ // Fill it in
+ pkgCache::DepIterator Dep(Cache,Cache.DepP + Dependency);
+ Dep->ParentVer = Ver.Index();
+ Dep->Type = Type;
+ Dep->CompareOp = Op;
+ Dep->ID = Cache.HeaderP->DependsCount++;
+
+ // Locate the target package
+ pkgCache::PkgIterator Pkg = Cache.FindPkg(Package);
+ if (Pkg.end() == true)
+ if (Owner->NewPackage(Pkg,Package) == false)
+ return false;
+
+ // Probe the reverse dependency list for a version string that matches
+ if (Version.empty() == false)
+ {
+ for (pkgCache::DepIterator I = Pkg.RevDependsList(); I.end() == false; I++)
+ if (I->Version != 0 && I.TargetVer() == Version)
+ Dep->Version = I->Version;
+ if (Dep->Version == 0)
+ if ((Dep->Version = WriteString(Version)) == 0)
+ return false;
+ }
+
+ // Link it to the package
+ Dep->Package = Pkg.Index();
+ Dep->NextRevDepends = Pkg->RevDepends;
+ Pkg->RevDepends = Dep.Index();
+
+ // Link it to the version (at the end of the list)
+ unsigned long *Last = &Ver->DependsList;
+ for (pkgCache::DepIterator D = Ver.DependsList(); D.end() == false; D++)
+ Last = &D->NextDepends;
+ Dep->NextDepends = *Last;
+ *Last = Dep.Index();
+
+ return true;
+}
+ /*}}}*/
+// ListParser::NewProvides - Create a Provides element /*{{{*/
+// ---------------------------------------------------------------------
+/* */
+bool pkgCacheGenerator::ListParser::NewProvides(pkgCache::VerIterator Ver,
+ string Package,string Version)
+{
+ pkgCache &Cache = Owner->Cache;
+
+ // Get a structure
+ unsigned long Provides = Owner->Map.Allocate(sizeof(pkgCache::Provides));
+ if (Provides == 0)
+ return false;
+
+ // Fill it in
+ pkgCache::PrvIterator Prv(Cache,Cache.ProvideP + Provides,Cache.PkgP);
+ Prv->Version = Ver.Index();
+ Prv->NextPkgProv = Ver->ProvidesList;
+ Ver->ProvidesList = Prv.Index();
+ if (Version.empty() == false && (Prv->Version = WriteString(Version)) == 0)
+ return false;
+
+ // Locate the target package
+ pkgCache::PkgIterator Pkg = Cache.FindPkg(Package);
+ if (Pkg.end() == true)
+ if (Owner->NewPackage(Pkg,Package) == false)
+ return false;
+
+ // Link it to the package
+ Prv->ParentPkg = Pkg.Index();
+ Prv->NextProvides = Pkg->ProvidesList;
+ Pkg->ProvidesList = Prv.Index();
+
+ return true;
+}
+ /*}}}*/
// CacheGenerator::SelectFile - Select the current file being parsed /*{{{*/
// ---------------------------------------------------------------------
/* This is used to select which file is to be associated with all newly
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
-// $Id: pkgcachegen.h,v 1.2 1998/07/04 05:57:38 jgg Exp $
+// $Id: pkgcachegen.h,v 1.3 1998/07/05 05:33:57 jgg Exp $
/* ######################################################################
Package Cache Generator - Generator for the cache structure.
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);};
+ bool NewDepends(pkgCache::VerIterator Ver,string Package,
+ string Version,unsigned int Op,
+ unsigned int Type);
+ bool NewProvides(pkgCache::VerIterator Ver,string Package,string Version);
public:
virtual string Package() = 0;
virtual string Version() = 0;
virtual bool NewVersion(pkgCache::VerIterator Ver) = 0;
- virtual bool NewPackage(pkgCache::PkgIterator Pkg) = 0;
virtual bool UsePackage(pkgCache::PkgIterator Pkg,
pkgCache::VerIterator Ver) = 0;
-
+ virtual unsigned long Offset() = 0;
+ virtual unsigned long Size() = 0;
+
virtual bool Step() = 0;
+
virtual ~ListParser() {};
};
friend ListParser;
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
-// $Id: tagfile.cc,v 1.3 1998/07/04 22:32:14 jgg Exp $
+// $Id: tagfile.cc,v 1.4 1998/07/05 05:33:58 jgg Exp $
/* ######################################################################
Fast scanner for RFC-822 type header information
Buffer = new char[64*1024];
Start = End = Buffer + 64*1024;
Left = Fd.Size();
+ iOffset = 0;
Fill();
}
/*}}}*/
if (Tag.Scan(Start,End - Start) == false)
return _error->Error("Unable to parse package file");
}
- Start += Tag.Length();
+ Start += Tag.size();
+ iOffset += Tag.size();
+
return true;
}
/*}}}*/
int main(int argc,char *argv[])
{
{
- File F(argv[1],File::ReadOnly);
File CacheF("./cache",File::WriteEmpty);
DynamicMMap Map(CacheF,MMap::Public);
pkgCacheGenerator Gen(Map);
- Gen.SelectFile(argv[1]);
-
- debListParser Parser(F);
- Gen.MergeList(Parser);
- }
+ for (int I = 1; I != argc; I++)
+ {
+ cout << "Merging in " << argv[I] << endl;
+ File F(argv[I],File::ReadOnly);
+ Gen.SelectFile(argv[I]);
+ debListParser Parser(F);
+ Gen.MergeList(Parser);
+ }
+ }
+/*
{
File CacheF("./cache",File::WriteExists);
MMap Map(CacheF,MMap::Public | MMap::ReadOnly);
cout << "Installed-Size: " << V->InstalledSize << endl;
cout << "Section: " << V.Section() << endl;
cout << "Priority: " << Cache.Priority(V->Priority) << endl;
- }
+
+ pkgCache::PrvIterator P = V.ProvidesList();
+ if (P.end() == false)
+ {
+ cout << "Provides: ";
+ for (; P.end() == false; P++)
+ cout << P.Name() << ", ";
+ cout << endl;
+ }
+ }
cout << endl;
}
}
-
+*/
#if 0
pkgTagSection I;
while (Test.Step(I) == true)
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
-// $Id: tagfile.h,v 1.1 1998/07/02 02:58:13 jgg Exp $
+// $Id: tagfile.h,v 1.2 1998/07/05 05:33:59 jgg Exp $
/* ######################################################################
Fast scanner for RFC-822 type header information
bool Find(const char *Tag,const char *&Start, const char *&End);
bool Scan(const char *Start,unsigned long MaxLength);
- inline unsigned long Length() {return Stop - Section;};
+ inline unsigned long size() {return Stop - Section;};
pkgTagSection() : Section(0), Stop(0) {};
};
char *Start;
char *End;
unsigned long Left;
+ unsigned long iOffset;
bool Fill();
public:
bool Step(pkgTagSection &Section);
+ inline unsigned long Offset() {return iOffset;};
pkgTagFile(File &F);
};
HCoop / ntk / apt.git / commitdiff