{"standard",pkgCache::State::Standard},
{"optional",pkgCache::State::Optional},
{"extra",pkgCache::State::Extra},
- {NULL, 0}};
+ {"", 0}};
// ListParser::debListParser - Constructor /*{{{*/
// ---------------------------------------------------------------------
// ListParser::Architecture - Return the package arch /*{{{*/
// ---------------------------------------------------------------------
/* This will return the Architecture of the package this section describes */
-string debListParser::Architecture() {
+APT::StringView debListParser::Architecture() {
auto const Arch = Section.Find("Architecture");
- return Arch.empty() ? "none" : Arch.to_string();
+ return Arch.empty() ? "none" : Arch;
}
/*}}}*/
// ListParser::ArchitectureAll /*{{{*/
/* 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()
+APT::StringView debListParser::Version()
{
- return Section.Find("Version").to_string();
+ return Section.Find("Version");
}
/*}}}*/
unsigned char debListParser::ParseMultiArch(bool const showErrors) /*{{{*/
Ver->Section = idx;
}
// Parse the source package name
- pkgCache::GrpIterator const G = Ver.ParentPkg().Group();
+ pkgCache::GrpIterator G = Ver.ParentPkg().Group();
Ver->SourcePkgName = G->Name;
Ver->SourceVerStr = Ver->VerStr;
if (Section.Find("Source",Start,Stop) == true)
if (Space != NULL)
{
- Stop = Space;
const char * const Open = (const char * const) memchr(Space, '(', Stop - Space);
if (likely(Open != NULL))
{
const char * const Close = (const char * const) memchr(Open, ')', Stop - Open);
if (likely(Close != NULL))
{
- std::string const version(Open + 1, (Close - Open) - 1);
+ APT::StringView const version(Open + 1, (Close - Open) - 1);
if (version != Ver.VerStr())
{
map_stringitem_t const idx = StoreString(pkgCacheGenerator::VERSIONNUMBER, version);
+ G = Ver.ParentPkg().Group();
Ver->SourceVerStr = idx;
}
}
}
+ Stop = Space;
}
- std::string const pkgname(Start, Stop - Start);
+ APT::StringView const pkgname(Start, Stop - Start);
if (pkgname != G.Name())
{
for (pkgCache::PkgIterator P = G.PackageList(); P.end() == false; P = G.NextPkg(P))
if (V.end() == true)
{
map_stringitem_t const idx = StoreString(pkgCacheGenerator::PKGNAME, pkgname);
+ G = Ver.ParentPkg().Group();
Ver->SourcePkgName = idx;
}
}
return true;
}
/*}}}*/
-// ListParser::Description - Return the description string /*{{{*/
-// ---------------------------------------------------------------------
-/* This is to return the string describing the package in debian
- form. If this returns the blank string then the entry is assumed to
- only describe package properties */
-string debListParser::Description(std::string const &lang)
-{
- return Description(StringView(lang)).to_string();
-}
-
-StringView debListParser::Description(StringView lang)
-{
- if (lang.empty())
- return Section.Find("Description");
- else
- return Section.Find(string("Description-").append(lang.data(), lang.size()));
-}
- /*}}}*/
// ListParser::AvailableDescriptionLanguages /*{{{*/
std::vector<std::string> debListParser::AvailableDescriptionLanguages()
{
*/
MD5SumValue debListParser::Description_md5()
{
- auto const value = Section.Find("Description-md5");
+ StringView const value = Section.Find("Description-md5");
if (value.empty() == true)
{
- StringView desc = Description(StringView("", 0));
+ StringView const desc = Section.Find("Description");
if (desc == "\n")
return MD5SumValue();
{"hold",pkgCache::State::Hold},
{"deinstall",pkgCache::State::DeInstall},
{"purge",pkgCache::State::Purge},
- {NULL, 0}};
+ {"", 0}};
if (GrabWord(StringView(Start,I-Start),WantList,Pkg->SelectedState) == false)
return _error->Error("Malformed 1st word in the Status line");
{"reinstreq",pkgCache::State::ReInstReq},
{"hold",pkgCache::State::HoldInst},
{"hold-reinstreq",pkgCache::State::HoldReInstReq},
- {NULL, 0}};
+ {"", 0}};
if (GrabWord(StringView(Start,I-Start),FlagList,Pkg->InstState) == false)
return _error->Error("Malformed 2nd word in the Status line");
{"triggers-awaited",pkgCache::State::TriggersAwaited},
{"triggers-pending",pkgCache::State::TriggersPending},
{"installed",pkgCache::State::Installed},
- {NULL, 0}};
+ {"", 0}};
if (GrabWord(StringView(Start,I-Start),StatusList,Pkg->CurrentState) == false)
return _error->Error("Malformed 3rd word in the Status line");
++I;
}
- std::string arch(I, End);
+ std::string const arch(I, End);
if (arch.empty() == false && matchesArch(arch.c_str()) == true)
{
Found = true;
++I;
}
- std::string restriction(I, End);
-
+ std::string const restriction(I, End);
if (restriction.empty() == false && profiles.empty() == false &&
std::find(profiles.begin(), profiles.end(), restriction) != profiles.end())
{
{
const char *Start;
const char *Stop;
- if (Section.Find(Tag,Start,Stop) == false)
+ if (Section.Find(Tag,Start,Stop) == false || Start == Stop)
return true;
string const pkgArch = Ver.Arch();
{
// Such dependencies are not supposed to be accepted …
// … but this is probably the best thing to do anyway
- std::string Pkg;
if (Package.substr(found + 1) == "native")
- Pkg = Package.substr(0, found).to_string() + ':' + Ver.Cache()->NativeArch();
- else
- Pkg = Package.to_string();
- if (NewDepends(Ver, Pkg, "any", Version, Op | pkgCache::Dep::ArchSpecific, Type) == false)
+ {
+ std::string const Pkg = Package.substr(0, found).to_string() + ':' + Ver.Cache()->NativeArch();
+ if (NewDepends(Ver, Pkg, "any", Version, Op | pkgCache::Dep::ArchSpecific, Type) == false)
+ return false;
+ }
+ else if (NewDepends(Ver, Package, "any", Version, Op | pkgCache::Dep::ArchSpecific, Type) == false)
return false;
}
// ListParser::GrabWord - Matches a word and returns /*{{{*/
// ---------------------------------------------------------------------
/* Looks for a word in a list of words - for ParseStatus */
-bool debListParser::GrabWord(StringView Word,const WordList *List,unsigned char &Out)
+bool debListParser::GrabWord(StringView Word, WordList const *List, unsigned char &Out)
{
- for (unsigned int C = 0; List[C].Str != 0; C++)
+ for (unsigned int C = 0; List[C].Str.empty() == false; C++)
{
- if (Word.length() == strlen(List[C].Str) &&
- strncasecmp(Word.data(),List[C].Str,Word.length()) == 0)
+ if (Word.length() == List[C].Str.length() &&
+ strncasecmp(Word.data(), List[C].Str.data(), Word.length()) == 0)
{
Out = List[C].Val;
return true;
projects / apt.git / blobdiff