#include <apt-pkg/strutl.h>
#include <apt-pkg/fileutl.h>
+#include <list>
+
#include <string>
#include <stdio.h>
#include <ctype.h>
using std::string;
-class pkgTagFilePrivate
+class APT_HIDDEN pkgTagFilePrivate /*{{{*/
{
public:
- pkgTagFilePrivate(FileFd *pFd, unsigned long long Size) : Fd(*pFd), Buffer(NULL),
- Start(NULL), End(NULL),
- Done(false), iOffset(0),
- Size(Size)
+ void Reset(FileFd * const pFd, unsigned long long const pSize, pkgTagFile::Flags const pFlags)
+ {
+ if (Buffer != NULL)
+ free(Buffer);
+ Buffer = NULL;
+ Fd = pFd;
+ Flags = pFlags;
+ Start = NULL;
+ End = NULL;
+ Done = false;
+ iOffset = 0;
+ Size = pSize;
+ isCommentedLine = false;
+ chunks.clear();
+ }
+
+ pkgTagFilePrivate(FileFd * const pFd, unsigned long long const Size, pkgTagFile::Flags const pFlags) : Buffer(NULL)
{
+ Reset(pFd, Size, pFlags);
}
- FileFd &Fd;
+ FileFd * Fd;
+ pkgTagFile::Flags Flags;
char *Buffer;
char *Start;
char *End;
bool Done;
unsigned long long iOffset;
unsigned long long Size;
-};
+ bool isCommentedLine;
+ struct FileChunk
+ {
+ bool const good;
+ size_t length;
+ FileChunk(bool const pgood, size_t const plength) : good(pgood), length(plength) {}
+ };
+ std::list<FileChunk> chunks;
-class pkgTagSectionPrivate
+ ~pkgTagFilePrivate()
+ {
+ if (Buffer != NULL)
+ free(Buffer);
+ }
+};
+ /*}}}*/
+class APT_HIDDEN pkgTagSectionPrivate /*{{{*/
{
public:
pkgTagSectionPrivate()
unsigned int StartValue;
unsigned int NextInBucket;
- TagData(unsigned int const StartTag) : StartTag(StartTag), EndTag(0), StartValue(0), NextInBucket(0) {}
+ explicit TagData(unsigned int const StartTag) : StartTag(StartTag), EndTag(0), StartValue(0), NextInBucket(0) {}
};
std::vector<TagData> Tags;
};
+ /*}}}*/
static unsigned long AlphaHash(const char *Text, size_t Length) /*{{{*/
{
/*}}}*/
// TagFile::pkgTagFile - Constructor /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-pkgTagFile::pkgTagFile(FileFd *pFd,unsigned long long Size)
- : d(NULL)
+pkgTagFile::pkgTagFile(FileFd * const pFd,pkgTagFile::Flags const pFlags, unsigned long long const Size)
+ : d(new pkgTagFilePrivate(pFd, Size + 4, pFlags))
{
- Init(pFd, Size);
+ Init(pFd, pFlags, Size);
}
-
-void pkgTagFile::Init(FileFd *pFd,unsigned long long Size)
+pkgTagFile::pkgTagFile(FileFd * const pFd,unsigned long long const Size)
+ : pkgTagFile(pFd, pkgTagFile::STRICT, Size)
+{
+}
+void pkgTagFile::Init(FileFd * const pFd, pkgTagFile::Flags const pFlags, unsigned long long Size)
{
/* The size is increased by 4 because if we start with the Size of the
filename we need to try to read 1 char more to see an EOF faster, 1
char the end-pointer can be on and maybe 2 newlines need to be added
to the end of the file -> 4 extra chars */
Size += 4;
- if(d != NULL)
- {
- free(d->Buffer);
- delete d;
- }
- d = new pkgTagFilePrivate(pFd, Size);
+ d->Reset(pFd, Size, pFlags);
- if (d->Fd.IsOpen() == false)
+ if (d->Fd->IsOpen() == false)
d->Start = d->End = d->Buffer = 0;
else
d->Buffer = (char*)malloc(sizeof(char) * Size);
d->iOffset = 0;
if (d->Done == false)
Fill();
+}
+void pkgTagFile::Init(FileFd * const pFd,unsigned long long Size)
+{
+ Init(pFd, pkgTagFile::STRICT, Size);
}
/*}}}*/
// TagFile::~pkgTagFile - Destructor /*{{{*/
-// ---------------------------------------------------------------------
-/* */
pkgTagFile::~pkgTagFile()
{
- free(d->Buffer);
delete d;
}
/*}}}*/
unsigned long long const EndSize = d->End - d->Start;
// get new buffer and use it
- char* newBuffer = (char*)realloc(d->Buffer, sizeof(char) * newSize);
+ char* const newBuffer = static_cast<char*>(realloc(d->Buffer, sizeof(char) * newSize));
if (newBuffer == NULL)
return false;
d->Buffer = newBuffer;
break;
if (Resize() == false)
- return _error->Error(_("Unable to parse package file %s (1)"),
- d->Fd.Name().c_str());
+ return _error->Error(_("Unable to parse package file %s (%d)"),
+ d->Fd->Name().c_str(), 1);
} while (Tag.Scan(d->Start,d->End - d->Start, false) == false);
}
- d->Start += Tag.size();
- d->iOffset += Tag.size();
+ size_t tagSize = Tag.size();
+ d->Start += tagSize;
+
+ if ((d->Flags & pkgTagFile::SUPPORT_COMMENTS) == 0)
+ d->iOffset += tagSize;
+ else
+ {
+ auto first = d->chunks.begin();
+ for (; first != d->chunks.end(); ++first)
+ {
+ if (first->good == false)
+ d->iOffset += first->length;
+ else
+ {
+ if (tagSize < first->length)
+ {
+ first->length -= tagSize;
+ d->iOffset += tagSize;
+ break;
+ }
+ else
+ {
+ tagSize -= first->length;
+ d->iOffset += first->length;
+ }
+ }
+ }
+ d->chunks.erase(d->chunks.begin(), first);
+ }
Tag.Trim();
return true;
// ---------------------------------------------------------------------
/* This takes the bit at the end of the buffer and puts it at the start
then fills the rest from the file */
+static bool FillBuffer(pkgTagFilePrivate * const d)
+{
+ unsigned long long Actual = 0;
+ // See if only a bit of the file is left
+ unsigned long long const dataSize = d->Size - ((d->End - d->Buffer) + 1);
+ if (d->Fd->Read(d->End, dataSize, &Actual) == false)
+ return false;
+ if (Actual != dataSize)
+ d->Done = true;
+ d->End += Actual;
+ return true;
+}
+static void RemoveCommentsFromBuffer(pkgTagFilePrivate * const d)
+{
+ // look for valid comments in the buffer
+ char * good_start = nullptr, * bad_start = nullptr;
+ char * current = d->Start;
+ if (d->isCommentedLine == false)
+ {
+ if (d->Start == d->Buffer)
+ {
+ // the start of the buffer is a newline as a record can't start
+ // in the middle of a line by definition.
+ if (*d->Start == '#')
+ {
+ d->isCommentedLine = true;
+ ++current;
+ if (current > d->End)
+ d->chunks.emplace_back(false, 1);
+ }
+ }
+ if (d->isCommentedLine == false)
+ good_start = d->Start;
+ else
+ bad_start = d->Start;
+ }
+ else
+ bad_start = d->Start;
+
+ std::vector<std::pair<char*, size_t>> good_parts;
+ while (current <= d->End)
+ {
+ size_t const restLength = (d->End - current) + 1;
+ if (d->isCommentedLine == false)
+ {
+ current = static_cast<char*>(memchr(current, '#', restLength));
+ if (current == nullptr)
+ {
+ size_t const goodLength = d->End - good_start;
+ d->chunks.emplace_back(true, goodLength);
+ if (good_start != d->Start)
+ good_parts.push_back(std::make_pair(good_start, goodLength));
+ break;
+ }
+ bad_start = current;
+ --current;
+ // ensure that this is really a comment and not a '#' in the middle of a line
+ if (*current == '\n')
+ {
+ size_t const goodLength = (current - good_start) + 1;
+ d->chunks.emplace_back(true, goodLength);
+ good_parts.push_back(std::make_pair(good_start, goodLength));
+ good_start = nullptr;
+ d->isCommentedLine = true;
+ }
+ current += 2;
+ }
+ else // the current line is a comment
+ {
+ current = static_cast<char*>(memchr(current, '\n', restLength));
+ if (current == nullptr)
+ {
+ d->chunks.emplace_back(false, (d->End - bad_start));
+ break;
+ }
+ ++current;
+ // is the next line a comment, too?
+ if (current > d->End || *current != '#')
+ {
+ d->chunks.emplace_back(false, (current - bad_start));
+ good_start = current;
+ bad_start = nullptr;
+ d->isCommentedLine = false;
+ }
+ ++current;
+ }
+ }
+
+ if (good_parts.empty() == false)
+ {
+ // we found comments, so move later parts over them
+ current = d->Start;
+ for (auto const &good: good_parts)
+ {
+ memmove(current, good.first, good.second);
+ current += good.second;
+ }
+ d->End = current;
+ }
+
+ if (d->isCommentedLine == true)
+ {
+ // deal with a buffer containing only comments
+ // or an (unfinished) comment at the end
+ if (good_parts.empty() == true)
+ d->End = d->Start;
+ else
+ d->Start = d->End;
+ }
+ else
+ {
+ // the buffer was all comment, but ended with the buffer
+ if (good_parts.empty() == true && good_start >= d->End)
+ d->End = d->Start;
+ else
+ d->Start = d->End;
+ }
+}
bool pkgTagFile::Fill()
{
- unsigned long long EndSize = d->End - d->Start;
+ unsigned long long const EndSize = d->End - d->Start;
+ if (EndSize != 0)
+ {
+ memmove(d->Buffer,d->Start,EndSize);
+ d->Start = d->End = d->Buffer + EndSize;
+ }
+ else
+ d->Start = d->End = d->Buffer;
+
unsigned long long Actual = 0;
-
- memmove(d->Buffer,d->Start,EndSize);
- d->Start = d->Buffer;
- d->End = d->Buffer + EndSize;
-
- if (d->Done == false)
+ while (d->Done == false && d->Size > (Actual + 1))
{
- // See if only a bit of the file is left
- unsigned long long const dataSize = d->Size - ((d->End - d->Buffer) + 1);
- if (d->Fd.Read(d->End, dataSize, &Actual) == false)
+ if (FillBuffer(d) == false)
return false;
- if (Actual != dataSize)
- d->Done = true;
- d->End += Actual;
+ if ((d->Flags & pkgTagFile::SUPPORT_COMMENTS) != 0)
+ RemoveCommentsFromBuffer(d);
+ Actual = d->End - d->Buffer;
}
-
+ d->Start = d->Buffer;
+
if (d->Done == true)
{
if (EndSize <= 3 && Actual == 0)
return false;
if (d->Size - (d->End - d->Buffer) < 4)
return true;
-
+
// Append a double new line if one does not exist
unsigned int LineCount = 0;
for (const char *E = d->End - 1; E - d->End < 6 && (*E == '\n' || *E == '\r'); E--)
if (*E == '\n')
- LineCount++;
+ ++LineCount;
if (LineCount < 2)
{
- if ((unsigned)(d->End - d->Buffer) >= d->Size)
+ if (static_cast<unsigned long long>(d->End - d->Buffer) >= d->Size)
Resize(d->Size + 3);
- for (; LineCount < 2; LineCount++)
+ for (; LineCount < 2; ++LineCount)
*d->End++ = '\n';
}
-
- return true;
}
-
return true;
}
/*}}}*/
that is there */
bool pkgTagFile::Jump(pkgTagSection &Tag,unsigned long long Offset)
{
+ if ((d->Flags & pkgTagFile::SUPPORT_COMMENTS) == 0 &&
// We are within a buffer space of the next hit..
- if (Offset >= d->iOffset && d->iOffset + (d->End - d->Start) > Offset)
+ Offset >= d->iOffset && d->iOffset + (d->End - d->Start) > Offset)
{
unsigned long long Dist = Offset - d->iOffset;
d->Start += Dist;
// Reposition and reload..
d->iOffset = Offset;
d->Done = false;
- if (d->Fd.Seek(Offset) == false)
+ if (d->Fd->Seek(Offset) == false)
return false;
d->End = d->Start = d->Buffer;
-
+ d->isCommentedLine = false;
+ d->chunks.clear();
+
if (Fill() == false)
return false;
return false;
if (Tag.Scan(d->Start, d->End - d->Start, false) == false)
- return _error->Error(_("Unable to parse package file %s (2)"),d->Fd.Name().c_str());
+ return _error->Error(_("Unable to parse package file %s (%d)"),d->Fd->Name().c_str(), 2);
return true;
}
/* */
APT_IGNORE_DEPRECATED_PUSH
pkgTagSection::pkgTagSection()
- : Section(0), d(NULL), Stop(0)
+ : Section(0), d(new pkgTagSectionPrivate()), Stop(0)
{
- d = new pkgTagSectionPrivate();
-#if APT_PKG_ABI < 413
- TagCount = 0;
- memset(&Indexes, 0, sizeof(Indexes));
-#endif
memset(&AlphaIndexes, 0, sizeof(AlphaIndexes));
}
APT_IGNORE_DEPRECATED_POP
/*}}}*/
// TagSection::Scan - Scan for the end of the header information /*{{{*/
-#if APT_PKG_ABI < 413
-bool pkgTagSection::Scan(const char *Start,unsigned long MaxLength)
-{
- return Scan(Start, MaxLength, true);
-}
-#endif
bool pkgTagSection::Scan(const char *Start,unsigned long MaxLength, bool const Restart)
{
Section = Start;
}
d->Tags.reserve(0x100);
}
-#if APT_PKG_ABI >= 413
unsigned int TagCount = d->Tags.size();
-#else
- APT_IGNORE_DEPRECATED(TagCount = d->Tags.size();)
-#endif
if (Stop == 0)
return false;
return true;
// Start a new index and add it to the hash
- if (isspace(Stop[0]) == 0)
+ if (isspace_ascii(Stop[0]) == 0)
{
// store the last found tag
if (lastTagData.EndTag != 0)
lastTagData.NextInBucket = AlphaIndexes[lastTagHash];
APT_IGNORE_DEPRECATED_PUSH
AlphaIndexes[lastTagHash] = TagCount;
-#if APT_PKG_ABI < 413
- if (d->Tags.size() < sizeof(Indexes)/sizeof(Indexes[0]))
- Indexes[d->Tags.size()] = lastTagData.StartTag;
-#endif
APT_IGNORE_DEPRECATED_POP
d->Tags.push_back(lastTagData);
}
// find the end of the tag (which might or might not be the colon)
char const * EndTag = Colon;
--EndTag;
- for (; EndTag > Stop && isspace(*EndTag) != 0; --EndTag)
+ for (; EndTag > Stop && isspace_ascii(*EndTag) != 0; --EndTag)
;
++EndTag;
lastTagData.EndTag = EndTag - Section;
lastTagHash = AlphaHash(Stop, EndTag - Stop);
// find the beginning of the value
Stop = Colon + 1;
- for (; isspace(*Stop) != 0; ++Stop);
+ for (; Stop < End && isspace_ascii(*Stop) != 0; ++Stop)
+ if (*Stop == '\n' && Stop[1] != ' ')
+ break;
if (Stop >= End)
return false;
lastTagData.StartValue = Stop - Section;
if (AlphaIndexes[lastTagHash] != 0)
lastTagData.NextInBucket = AlphaIndexes[lastTagHash];
APT_IGNORE_DEPRECATED(AlphaIndexes[lastTagHash] = TagCount;)
-#if APT_PKG_ABI < 413
- APT_IGNORE_DEPRECATED(Indexes[d->Tags.size()] = lastTagData.StartTag;)
-#endif
d->Tags.push_back(lastTagData);
}
pkgTagSectionPrivate::TagData const td(Stop - Section);
-#if APT_PKG_ABI < 413
- APT_IGNORE_DEPRECATED(Indexes[d->Tags.size()] = td.StartTag;)
-#endif
d->Tags.push_back(td);
TrimRecord(false,End);
return true;
}
/*}}}*/
// TagSection::Exists - return True if a tag exists /*{{{*/
-#if APT_PKG_ABI >= 413
bool pkgTagSection::Exists(const char* const Tag) const
-#else
-bool pkgTagSection::Exists(const char* const Tag)
-#endif
{
unsigned int tmp;
return Find(Tag, tmp);
if (unlikely(Start > End))
return _error->Error("Internal parsing error");
- for (; isspace(End[-1]) != 0 && End > Start; --End);
+ for (; isspace_ascii(End[-1]) != 0 && End > Start; --End);
return true;
}
/*}}}*/
// TagSection::FindS - Find a string /*{{{*/
-// ---------------------------------------------------------------------
-/* */
string pkgTagSection::FindS(const char *Tag) const
{
const char *Start;
return string(Start,End);
}
/*}}}*/
+// TagSection::FindRawS - Find a string /*{{{*/
+string pkgTagSection::FindRawS(const char *Tag) const
+{
+ unsigned int Pos;
+ if (Find(Tag, Pos) == false)
+ return "";
+
+ char const *Start = (char const *) memchr(Section + d->Tags[Pos].EndTag, ':', d->Tags[Pos].StartValue - d->Tags[Pos].EndTag);
+ ++Start;
+ char const *End = Section + d->Tags[Pos + 1].StartTag;
+ if (unlikely(Start > End))
+ return "";
+
+ for (; isspace_ascii(End[-1]) != 0 && End > Start; --End);
+
+ return std::string(Start, End - Start);
+}
+ /*}}}*/
// TagSection::FindI - Find an integer /*{{{*/
// ---------------------------------------------------------------------
/* */
return Default;
strncpy(S,Start,Stop-Start);
S[Stop - Start] = 0;
-
+
+ errno = 0;
char *End;
signed long Result = strtol(S,&End,10);
+ if (errno == ERANGE ||
+ Result < std::numeric_limits<int>::min() || Result > std::numeric_limits<int>::max()) {
+ errno = ERANGE;
+ _error->Error(_("Cannot convert %s to integer: out of range"), S);
+ }
if (S == End)
return Default;
return Result;
// TagSection::FindFlag - Locate a yes/no type flag /*{{{*/
// ---------------------------------------------------------------------
/* The bits marked in Flag are masked on/off in Flags */
+bool pkgTagSection::FindFlag(const char * const Tag, uint8_t &Flags,
+ uint8_t const Flag) const
+{
+ const char *Start;
+ const char *Stop;
+ if (Find(Tag,Start,Stop) == false)
+ return true;
+ return FindFlag(Flags, Flag, Start, Stop);
+}
+bool pkgTagSection::FindFlag(uint8_t &Flags, uint8_t const Flag,
+ char const* const Start, char const* const Stop)
+{
+ switch (StringToBool(string(Start, Stop)))
+ {
+ case 0:
+ Flags &= ~Flag;
+ return true;
+
+ case 1:
+ Flags |= Flag;
+ return true;
+
+ default:
+ _error->Warning("Unknown flag value: %s",string(Start,Stop).c_str());
+ return true;
+ }
+ return true;
+}
bool pkgTagSection::FindFlag(const char *Tag,unsigned long &Flags,
unsigned long Flag) const
{
return true;
}
/*}}}*/
-void pkgTagSection::Get(const char *&Start,const char *&Stop,unsigned int I) const
+void pkgTagSection::Get(const char *&Start,const char *&Stop,unsigned int I) const/*{{{*/
{
Start = Section + d->Tags[I].StartTag;
Stop = Section + d->Tags[I+1].StartTag;
}
+ /*}}}*/
APT_PURE unsigned int pkgTagSection::Count() const { /*{{{*/
if (d->Tags.empty() == true)
return 0;
return d->Tags.size() - 1;
}
/*}}}*/
+// TagSection::Write - Ordered (re)writing of fields /*{{{*/
+pkgTagSection::Tag pkgTagSection::Tag::Remove(std::string const &Name)
+{
+ return Tag(REMOVE, Name, "");
+}
+pkgTagSection::Tag pkgTagSection::Tag::Rename(std::string const &OldName, std::string const &NewName)
+{
+ return Tag(RENAME, OldName, NewName);
+}
+pkgTagSection::Tag pkgTagSection::Tag::Rewrite(std::string const &Name, std::string const &Data)
+{
+ if (Data.empty() == true)
+ return Tag(REMOVE, Name, "");
+ else
+ return Tag(REWRITE, Name, Data);
+}
+static bool WriteTag(FileFd &File, std::string Tag, std::string const &Value)
+{
+ if (Value.empty() || isspace_ascii(Value[0]) != 0)
+ Tag.append(":");
+ else
+ Tag.append(": ");
+ Tag.append(Value);
+ Tag.append("\n");
+ return File.Write(Tag.c_str(), Tag.length());
+}
+static bool RewriteTags(FileFd &File, pkgTagSection const * const This, char const * const Tag,
+ std::vector<pkgTagSection::Tag>::const_iterator &R,
+ std::vector<pkgTagSection::Tag>::const_iterator const &REnd)
+{
+ size_t const TagLen = strlen(Tag);
+ for (; R != REnd; ++R)
+ {
+ std::string data;
+ if (R->Name.length() == TagLen && strncasecmp(R->Name.c_str(), Tag, R->Name.length()) == 0)
+ {
+ if (R->Action != pkgTagSection::Tag::REWRITE)
+ break;
+ data = R->Data;
+ }
+ else if(R->Action == pkgTagSection::Tag::RENAME && R->Data.length() == TagLen &&
+ strncasecmp(R->Data.c_str(), Tag, R->Data.length()) == 0)
+ data = This->FindRawS(R->Name.c_str());
+ else
+ continue;
+
+ return WriteTag(File, Tag, data);
+ }
+ return true;
+}
+bool pkgTagSection::Write(FileFd &File, char const * const * const Order, std::vector<Tag> const &Rewrite) const
+{
+ // first pass: Write everything we have an order for
+ if (Order != NULL)
+ {
+ for (unsigned int I = 0; Order[I] != 0; ++I)
+ {
+ std::vector<Tag>::const_iterator R = Rewrite.begin();
+ if (RewriteTags(File, this, Order[I], R, Rewrite.end()) == false)
+ return false;
+ if (R != Rewrite.end())
+ continue;
+
+ if (Exists(Order[I]) == false)
+ continue;
+
+ if (WriteTag(File, Order[I], FindRawS(Order[I])) == false)
+ return false;
+ }
+ }
+ // second pass: See if we have tags which aren't ordered
+ if (d->Tags.empty() == false)
+ {
+ for (std::vector<pkgTagSectionPrivate::TagData>::const_iterator T = d->Tags.begin(); T != d->Tags.end() - 1; ++T)
+ {
+ char const * const fieldname = Section + T->StartTag;
+ size_t fieldnamelen = T->EndTag - T->StartTag;
+ if (Order != NULL)
+ {
+ unsigned int I = 0;
+ for (; Order[I] != 0; ++I)
+ {
+ if (fieldnamelen == strlen(Order[I]) && strncasecmp(fieldname, Order[I], fieldnamelen) == 0)
+ break;
+ }
+ if (Order[I] != 0)
+ continue;
+ }
+
+ std::string const name(fieldname, fieldnamelen);
+ std::vector<Tag>::const_iterator R = Rewrite.begin();
+ if (RewriteTags(File, this, name.c_str(), R, Rewrite.end()) == false)
+ return false;
+ if (R != Rewrite.end())
+ continue;
+
+ if (WriteTag(File, name, FindRawS(name.c_str())) == false)
+ return false;
+ }
+ }
+ // last pass: see if there are any rewrites remaining we haven't done yet
+ for (std::vector<Tag>::const_iterator R = Rewrite.begin(); R != Rewrite.end(); ++R)
+ {
+ if (R->Action == Tag::REMOVE)
+ continue;
+ std::string const name = ((R->Action == Tag::RENAME) ? R->Data : R->Name);
+ if (Exists(name.c_str()))
+ continue;
+ if (Order != NULL)
+ {
+ unsigned int I = 0;
+ for (; Order[I] != 0; ++I)
+ {
+ if (strncasecmp(name.c_str(), Order[I], name.length()) == 0 && name.length() == strlen(Order[I]))
+ break;
+ }
+ if (Order[I] != 0)
+ continue;
+ }
+
+ if (WriteTag(File, name, ((R->Action == Tag::RENAME) ? FindRawS(R->Name.c_str()) : R->Data)) == false)
+ return false;
+ }
+ return true;
+}
+ /*}}}*/
+
+void pkgUserTagSection::TrimRecord(bool /*BeforeRecord*/, const char* &End)/*{{{*/
+{
+ for (; Stop < End && (Stop[0] == '\n' || Stop[0] == '\r' || Stop[0] == '#'); Stop++)
+ if (Stop[0] == '#')
+ Stop = (const char*) memchr(Stop,'\n',End-Stop);
+}
+ /*}}}*/
+
+#include "tagfile-order.c"
+
// TFRewrite - Rewrite a control record /*{{{*/
// ---------------------------------------------------------------------
/* This writes the control record to stdout rewriting it as necessary. The
override map item specificies the rewriting rules to follow. This also
takes the time to sort the feild list. */
-
-/* The order of this list is taken from dpkg source lib/parse.c the fieldinfos
- array. */
-static const char *iTFRewritePackageOrder[] = {
- "Package",
- "Essential",
- "Status",
- "Priority",
- "Section",
- "Installed-Size",
- "Maintainer",
- "Original-Maintainer",
- "Architecture",
- "Source",
- "Version",
- "Revision", // Obsolete
- "Config-Version", // Obsolete
- "Replaces",
- "Provides",
- "Depends",
- "Pre-Depends",
- "Recommends",
- "Suggests",
- "Conflicts",
- "Breaks",
- "Conffiles",
- "Filename",
- "Size",
- "MD5sum",
- "SHA1",
- "SHA256",
- "SHA512",
- "MSDOS-Filename", // Obsolete
- "Description",
- 0};
-static const char *iTFRewriteSourceOrder[] = {"Package",
- "Source",
- "Binary",
- "Version",
- "Priority",
- "Section",
- "Maintainer",
- "Original-Maintainer",
- "Build-Depends",
- "Build-Depends-Indep",
- "Build-Conflicts",
- "Build-Conflicts-Indep",
- "Architecture",
- "Standards-Version",
- "Format",
- "Directory",
- "Files",
- 0};
-
-/* Two levels of initialization are used because gcc will set the symbol
- size of an array to the length of the array, causing dynamic relinking
- errors. Doing this makes the symbol size constant */
-const char **TFRewritePackageOrder = iTFRewritePackageOrder;
-const char **TFRewriteSourceOrder = iTFRewriteSourceOrder;
-
+APT_IGNORE_DEPRECATED_PUSH
bool TFRewrite(FILE *Output,pkgTagSection const &Tags,const char *Order[],
TFRewriteData *Rewrite)
{
Visited[J] |= 2;
if (Rewrite[J].Rewrite != 0 && Rewrite[J].Rewrite[0] != 0)
{
- if (isspace(Rewrite[J].Rewrite[0]))
+ if (isspace_ascii(Rewrite[J].Rewrite[0]))
fprintf(Output,"%s:%s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
else
fprintf(Output,"%s: %s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
Visited[J] |= 2;
if (Rewrite[J].Rewrite != 0 && Rewrite[J].Rewrite[0] != 0)
{
- if (isspace(Rewrite[J].Rewrite[0]))
+ if (isspace_ascii(Rewrite[J].Rewrite[0]))
fprintf(Output,"%s:%s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
else
fprintf(Output,"%s: %s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
if (Rewrite[J].Rewrite != 0 && Rewrite[J].Rewrite[0] != 0)
{
- if (isspace(Rewrite[J].Rewrite[0]))
+ if (isspace_ascii(Rewrite[J].Rewrite[0]))
fprintf(Output,"%s:%s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
else
fprintf(Output,"%s: %s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
return true;
}
+APT_IGNORE_DEPRECATED_POP
/*}}}*/
pkgTagSection::~pkgTagSection() { delete d; }
projects / apt.git / blobdiff