i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

* some rearrangements and renames with respect to public/private

Browse Source 
types and defines of HPKG
* added header, magic and version for haiku repository format

git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@40370 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Oliver Tappe
2011-02-07 13:04:00 +00:00
parent 5658c5ff2a
commit aaf05784d4
4 changed files with 170 additions and 156 deletions
Download Patch File Download Diff File Expand all files Collapse all files
headers/os/package/hpkg/HPKGDefs.h
+25 -3
View File
@@ -14,10 +14,13 @@ namespace BPackageKit {
namespace BHPKG { namespace BHPKG {
// magic, version // magic & version of package and repository files
enum { enum {
B_HPKG_MAGIC = 'hpkg', B_HPKG_MAGIC = 'hpkg',
B_HPKG_VERSION = 1 B_HPKG_VERSION = 1,
//
B_HPKG_REPO_MAGIC = 'hpkr',
B_HPKG_REPO_VERSION = 1
}; };
@@ -92,9 +95,28 @@ enum BPackageAttributeID {
}; };
// TODO: make this accessible via a function // compression types
enum {
B_HPKG_COMPRESSION_NONE = 0,
B_HPKG_COMPRESSION_ZLIB = 1
};
// file types (HPKG_ATTRIBUTE_NAME_FILE_TYPE)
enum {
B_HPKG_FILE_TYPE_FILE = 0,
B_HPKG_FILE_TYPE_DIRECTORY = 1,
B_HPKG_FILE_TYPE_SYMLINK = 2
};
// default values // default values
enum { enum {
B_HPKG_DEFAULT_FILE_TYPE = B_HPKG_FILE_TYPE_FILE,
B_HPKG_DEFAULT_FILE_PERMISSIONS = 0644,
B_HPKG_DEFAULT_DIRECTORY_PERMISSIONS = 0755,
B_HPKG_DEFAULT_SYMLINK_PERMISSIONS = 0777,
B_HPKG_DEFAULT_DATA_COMPRESSION = B_HPKG_COMPRESSION_NONE,
B_HPKG_DEFAULT_DATA_CHUNK_SIZE_ZLIB = 64 * 1024 B_HPKG_DEFAULT_DATA_CHUNK_SIZE_ZLIB = 64 * 1024
}; };
headers/private/package/hpkg/haiku_package.h
+64 -72
View File
@@ -42,116 +42,108 @@ struct hpkg_header {
}; };
// compression types // header
enum { struct hpkg_repo_header {
B_HPKG_COMPRESSION_NONE = 0, uint32 magic; // "hpkr"
B_HPKG_COMPRESSION_ZLIB = 1 uint16 header_size;
uint16 version;
uint64 total_size;
// package attributes section
uint32 attributes_compression;
uint32 attributes_length_compressed;
uint32 attributes_length_uncompressed;
uint64 attributes_strings_length;
uint64 attributes_strings_count;
}; };
// attribute tag arithmetics // attribute tag arithmetics
#define B_HPKG_ATTRIBUTE_TAG_COMPOSE(index, encoding, hasChildren) \ #define HPKG_ATTRIBUTE_TAG_COMPOSE(index, encoding, hasChildren) \
(((uint64(index) << 3) | uint64(encoding) << 1 \ (((uint64(index) << 3) | uint64(encoding) << 1 \
| ((hasChildren) ? 1 : 0)) + 1) | ((hasChildren) ? 1 : 0)) + 1)
#define B_HPKG_ATTRIBUTE_TAG_INDEX(tag) (uint64((tag) - 1) >> 3) #define HPKG_ATTRIBUTE_TAG_INDEX(tag) (uint64((tag) - 1) >> 3)
#define B_HPKG_ATTRIBUTE_TAG_ENCODING(tag) ((uint64((tag) - 1) >> 1) & 0x3) #define HPKG_ATTRIBUTE_TAG_ENCODING(tag) ((uint64((tag) - 1) >> 1) & 0x3)
#define B_HPKG_ATTRIBUTE_TAG_HAS_CHILDREN(tag) ((uint64((tag) - 1) & 0x1) != 0) #define HPKG_ATTRIBUTE_TAG_HAS_CHILDREN(tag) ((uint64((tag) - 1) & 0x1) != 0)
// package attribute tag arithmetics // package attribute tag arithmetics
#define B_HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE(id, type, encoding, hasChildren) \ #define HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE(id, type, encoding, hasChildren) \
(((uint16(encoding) << 9) | (((hasChildren) ? 1 : 0) << 8) \ (((uint16(encoding) << 9) | (((hasChildren) ? 1 : 0) << 8) \
| (uint16(type) << 5) | (uint16(id))) + 1) | (uint16(type) << 5) | (uint16(id))) + 1)
#define B_HPKG_PACKAGE_ATTRIBUTE_TAG_ENCODING(tag) \ #define HPKG_PACKAGE_ATTRIBUTE_TAG_ENCODING(tag) \
((uint16((tag) - 1) >> 9) & 0x3) ((uint16((tag) - 1) >> 9) & 0x3)
#define B_HPKG_PACKAGE_ATTRIBUTE_TAG_HAS_CHILDREN(tag) \ #define HPKG_PACKAGE_ATTRIBUTE_TAG_HAS_CHILDREN(tag) \
(((uint16((tag) - 1) >> 8) & 0x1) != 0) (((uint16((tag) - 1) >> 8) & 0x1) != 0)
#define B_HPKG_PACKAGE_ATTRIBUTE_TAG_TYPE(tag) \ #define HPKG_PACKAGE_ATTRIBUTE_TAG_TYPE(tag) \
((uint16((tag) - 1) >> 5) & 0x7) ((uint16((tag) - 1) >> 5) & 0x7)
#define B_HPKG_PACKAGE_ATTRIBUTE_TAG_ID(tag) \ #define HPKG_PACKAGE_ATTRIBUTE_TAG_ID(tag) \
(uint16((tag) - 1) & 0x1f) (uint16((tag) - 1) & 0x1f)
// standard attribute names // standard attribute names
#define B_HPKG_ATTRIBUTE_NAME_DIRECTORY_ENTRY "dir:entry" #define HPKG_ATTRIBUTE_NAME_DIRECTORY_ENTRY "dir:entry"
// path/entry name (string) // path/entry name (string)
#define B_HPKG_ATTRIBUTE_NAME_FILE_TYPE "file:type" #define HPKG_ATTRIBUTE_NAME_FILE_TYPE "file:type"
// file type (uint) // file type (uint)
#define B_HPKG_ATTRIBUTE_NAME_FILE_PERMISSIONS "file:permissions" #define HPKG_ATTRIBUTE_NAME_FILE_PERMISSIONS "file:permissions"
// file permissions (uint) // file permissions (uint)
#define B_HPKG_ATTRIBUTE_NAME_FILE_USER "file:user" #define HPKG_ATTRIBUTE_NAME_FILE_USER "file:user"
// file user (string) // file user (string)
#define B_HPKG_ATTRIBUTE_NAME_FILE_GROUP "file:group" #define HPKG_ATTRIBUTE_NAME_FILE_GROUP "file:group"
// file group (string) // file group (string)
#define B_HPKG_ATTRIBUTE_NAME_FILE_ATIME "file:atime" #define HPKG_ATTRIBUTE_NAME_FILE_ATIME "file:atime"
// file access time in seconds (uint) // file access time in seconds (uint)
#define B_HPKG_ATTRIBUTE_NAME_FILE_MTIME "file:mtime" #define HPKG_ATTRIBUTE_NAME_FILE_MTIME "file:mtime"
// file modification time in seconds (uint) // file modification time in seconds (uint)
#define B_HPKG_ATTRIBUTE_NAME_FILE_CRTIME "file:crtime" #define HPKG_ATTRIBUTE_NAME_FILE_CRTIME "file:crtime"
// file creation time in seconds (uint) // file creation time in seconds (uint)
#define B_HPKG_ATTRIBUTE_NAME_FILE_ATIME_NANOS "file:atime:nanos" #define HPKG_ATTRIBUTE_NAME_FILE_ATIME_NANOS "file:atime:nanos"
// file access time nanoseconds fraction (uint) // file access time nanoseconds fraction (uint)
#define B_HPKG_ATTRIBUTE_NAME_FILE_MTIME_NANOS "file:mtime:nanos" #define HPKG_ATTRIBUTE_NAME_FILE_MTIME_NANOS "file:mtime:nanos"
// file modification time nanoseconds fraction (uint) // file modification time nanoseconds fraction (uint)
#define B_HPKG_ATTRIBUTE_NAME_FILE_CRTIM_NANOS "file:crtime:nanos" #define HPKG_ATTRIBUTE_NAME_FILE_CRTIM_NANOS "file:crtime:nanos"
// file creation time nanoseconds fraction (uint) // file creation time nanoseconds fraction (uint)
#define B_HPKG_ATTRIBUTE_NAME_FILE_ATTRIBUTE "file:attribute" #define HPKG_ATTRIBUTE_NAME_FILE_ATTRIBUTE "file:attribute"
// file attribute (string) // file attribute (string)
#define B_HPKG_ATTRIBUTE_NAME_FILE_ATTRIBUTE_TYPE "file:attribute:type" #define HPKG_ATTRIBUTE_NAME_FILE_ATTRIBUTE_TYPE "file:attribute:type"
// file attribute type (uint) // file attribute type (uint)
#define B_HPKG_ATTRIBUTE_NAME_DATA "data" #define HPKG_ATTRIBUTE_NAME_DATA "data"
// (file/attribute) data (raw) // (file/attribute) data (raw)
#define B_HPKG_ATTRIBUTE_NAME_DATA_COMPRESSION "data:compression" #define HPKG_ATTRIBUTE_NAME_DATA_COMPRESSION "data:compression"
// (file/attribute) data compression (uint, default: none) // (file/attribute) data compression (uint, default: none)
#define B_HPKG_ATTRIBUTE_NAME_DATA_SIZE "data:size" #define HPKG_ATTRIBUTE_NAME_DATA_SIZE "data:size"
// (file/attribute) uncompressed data size (uint) // (file/attribute) uncompressed data size (uint)
#define B_HPKG_ATTRIBUTE_NAME_DATA_CHUNK_SIZE "data:chunk_size" #define HPKG_ATTRIBUTE_NAME_DATA_CHUNK_SIZE "data:chunk_size"
// the size of compressed (file/attribute) data chunks (uint) // the size of compressed (file/attribute) data chunks (uint)
#define B_HPKG_ATTRIBUTE_NAME_SYMLINK_PATH "symlink:path" #define HPKG_ATTRIBUTE_NAME_SYMLINK_PATH "symlink:path"
// symlink path (string) // symlink path (string)
// file types (B_HPKG_ATTRIBUTE_NAME_FILE_TYPE)
enum {
B_HPKG_FILE_TYPE_FILE = 0,
B_HPKG_FILE_TYPE_DIRECTORY = 1,
B_HPKG_FILE_TYPE_SYMLINK = 2
};
// default values
enum {
B_HPKG_DEFAULT_FILE_TYPE = B_HPKG_FILE_TYPE_FILE,
B_HPKG_DEFAULT_FILE_PERMISSIONS = 0644,
B_HPKG_DEFAULT_DIRECTORY_PERMISSIONS = 0755,
B_HPKG_DEFAULT_SYMLINK_PERMISSIONS = 0777,
B_HPKG_DEFAULT_DATA_COMPRESSION = B_HPKG_COMPRESSION_NONE,
};
// package attribute IDs // package attribute IDs
enum BHPKGPackageAttributeID { enum HPKGPackageAttributeID {
B_HPKG_PACKAGE_ATTRIBUTE_NAME = 0, HPKG_PACKAGE_ATTRIBUTE_NAME = 0,
B_HPKG_PACKAGE_ATTRIBUTE_SUMMARY, HPKG_PACKAGE_ATTRIBUTE_SUMMARY,
B_HPKG_PACKAGE_ATTRIBUTE_DESCRIPTION, HPKG_PACKAGE_ATTRIBUTE_DESCRIPTION,
B_HPKG_PACKAGE_ATTRIBUTE_VENDOR, HPKG_PACKAGE_ATTRIBUTE_VENDOR,
B_HPKG_PACKAGE_ATTRIBUTE_PACKAGER, HPKG_PACKAGE_ATTRIBUTE_PACKAGER,
B_HPKG_PACKAGE_ATTRIBUTE_ARCHITECTURE, HPKG_PACKAGE_ATTRIBUTE_ARCHITECTURE,
B_HPKG_PACKAGE_ATTRIBUTE_VERSION_MAJOR, HPKG_PACKAGE_ATTRIBUTE_VERSION_MAJOR,
B_HPKG_PACKAGE_ATTRIBUTE_VERSION_MINOR, HPKG_PACKAGE_ATTRIBUTE_VERSION_MINOR,
B_HPKG_PACKAGE_ATTRIBUTE_VERSION_MICRO, HPKG_PACKAGE_ATTRIBUTE_VERSION_MICRO,
B_HPKG_PACKAGE_ATTRIBUTE_VERSION_RELEASE, HPKG_PACKAGE_ATTRIBUTE_VERSION_RELEASE,
B_HPKG_PACKAGE_ATTRIBUTE_COPYRIGHT, HPKG_PACKAGE_ATTRIBUTE_COPYRIGHT,
B_HPKG_PACKAGE_ATTRIBUTE_LICENSE, HPKG_PACKAGE_ATTRIBUTE_LICENSE,
B_HPKG_PACKAGE_ATTRIBUTE_PROVIDES, HPKG_PACKAGE_ATTRIBUTE_PROVIDES,
B_HPKG_PACKAGE_ATTRIBUTE_PROVIDES_TYPE, HPKG_PACKAGE_ATTRIBUTE_PROVIDES_TYPE,
B_HPKG_PACKAGE_ATTRIBUTE_REQUIRES, HPKG_PACKAGE_ATTRIBUTE_REQUIRES,
B_HPKG_PACKAGE_ATTRIBUTE_SUPPLEMENTS, HPKG_PACKAGE_ATTRIBUTE_SUPPLEMENTS,
B_HPKG_PACKAGE_ATTRIBUTE_CONFLICTS, HPKG_PACKAGE_ATTRIBUTE_CONFLICTS,
B_HPKG_PACKAGE_ATTRIBUTE_FRESHENS, HPKG_PACKAGE_ATTRIBUTE_FRESHENS,
B_HPKG_PACKAGE_ATTRIBUTE_REPLACES, HPKG_PACKAGE_ATTRIBUTE_REPLACES,
B_HPKG_PACKAGE_ATTRIBUTE_RESOLVABLE_OPERATOR, HPKG_PACKAGE_ATTRIBUTE_RESOLVABLE_OPERATOR,
// //
B_HPKG_PACKAGE_ATTRIBUTE_ENUM_COUNT, HPKG_PACKAGE_ATTRIBUTE_ENUM_COUNT,
}; };
src/kits/package/hpkg/PackageReaderImpl.cpp
+30 -30
View File
@@ -80,7 +80,7 @@ struct standard_attribute_index_entry {
#undef MAKE_ATTRIBUTE_INDEX_ENTRY #undef MAKE_ATTRIBUTE_INDEX_ENTRY
#define MAKE_ATTRIBUTE_INDEX_ENTRY(name, type) \ #define MAKE_ATTRIBUTE_INDEX_ENTRY(name, type) \
{ B_HPKG_ATTRIBUTE_NAME_##name, B_HPKG_ATTRIBUTE_TYPE_##type, \ { HPKG_ATTRIBUTE_NAME_##name, B_HPKG_ATTRIBUTE_TYPE_##type, \
ATTRIBUTE_INDEX_##name } ATTRIBUTE_INDEX_##name }
static const standard_attribute_index_entry kStandardAttributeIndices[] = { static const standard_attribute_index_entry kStandardAttributeIndices[] = {
@@ -1063,7 +1063,7 @@ PackageReaderImpl::_ParseAttributeTree(AttributeHandlerContext* context)
} }
// get the type // get the type
uint64 typeIndex = B_HPKG_ATTRIBUTE_TAG_INDEX(tag); uint64 typeIndex = HPKG_ATTRIBUTE_TAG_INDEX(tag);
if (typeIndex >= fTOCAttributeTypesCount) { if (typeIndex >= fTOCAttributeTypesCount) {
fErrorOutput->PrintError("Error: Invalid TOC section: " fErrorOutput->PrintError("Error: Invalid TOC section: "
"Invalid attribute type index\n"); "Invalid attribute type index\n");
@@ -1074,11 +1074,11 @@ PackageReaderImpl::_ParseAttributeTree(AttributeHandlerContext* context)
// get the value // get the value
AttributeValue value; AttributeValue value;
error = _ReadAttributeValue(type->type->type, error = _ReadAttributeValue(type->type->type,
B_HPKG_ATTRIBUTE_TAG_ENCODING(tag), value); HPKG_ATTRIBUTE_TAG_ENCODING(tag), value);
if (error != B_OK) if (error != B_OK)
return error; return error;
bool hasChildren = B_HPKG_ATTRIBUTE_TAG_HAS_CHILDREN(tag); bool hasChildren = HPKG_ATTRIBUTE_TAG_HAS_CHILDREN(tag);
AttributeHandler* childHandler = NULL; AttributeHandler* childHandler = NULL;
error = _CurrentAttributeHandler()->HandleChildAttribute(context, error = _CurrentAttributeHandler()->HandleChildAttribute(context,
type->type, type->standardIndex, value, type->type, type->standardIndex, value,
@@ -1124,31 +1124,31 @@ PackageReaderImpl::_ParsePackageAttributes(AttributeHandlerContext* context)
return B_OK; return B_OK;
switch (id) { switch (id) {
case B_HPKG_PACKAGE_ATTRIBUTE_NAME: case HPKG_PACKAGE_ATTRIBUTE_NAME:
handlerValue.SetTo(B_PACKAGE_INFO_NAME, attributeValue.string); handlerValue.SetTo(B_PACKAGE_INFO_NAME, attributeValue.string);
break; break;
case B_HPKG_PACKAGE_ATTRIBUTE_SUMMARY: case HPKG_PACKAGE_ATTRIBUTE_SUMMARY:
handlerValue.SetTo(B_PACKAGE_INFO_SUMMARY, handlerValue.SetTo(B_PACKAGE_INFO_SUMMARY,
attributeValue.string); attributeValue.string);
break; break;
case B_HPKG_PACKAGE_ATTRIBUTE_DESCRIPTION: case HPKG_PACKAGE_ATTRIBUTE_DESCRIPTION:
handlerValue.SetTo(B_PACKAGE_INFO_DESCRIPTION, handlerValue.SetTo(B_PACKAGE_INFO_DESCRIPTION,
attributeValue.string); attributeValue.string);
break; break;
case B_HPKG_PACKAGE_ATTRIBUTE_VENDOR: case HPKG_PACKAGE_ATTRIBUTE_VENDOR:
handlerValue.SetTo(B_PACKAGE_INFO_VENDOR, handlerValue.SetTo(B_PACKAGE_INFO_VENDOR,
attributeValue.string); attributeValue.string);
break; break;
case B_HPKG_PACKAGE_ATTRIBUTE_PACKAGER: case HPKG_PACKAGE_ATTRIBUTE_PACKAGER:
handlerValue.SetTo(B_PACKAGE_INFO_PACKAGER, handlerValue.SetTo(B_PACKAGE_INFO_PACKAGER,
attributeValue.string); attributeValue.string);
break; break;
case B_HPKG_PACKAGE_ATTRIBUTE_ARCHITECTURE: case HPKG_PACKAGE_ATTRIBUTE_ARCHITECTURE:
if (attributeValue.unsignedInt if (attributeValue.unsignedInt
>= B_PACKAGE_ARCHITECTURE_ENUM_COUNT) { >= B_PACKAGE_ARCHITECTURE_ENUM_COUNT) {
fErrorOutput->PrintError( fErrorOutput->PrintError(
@@ -1161,7 +1161,7 @@ PackageReaderImpl::_ParsePackageAttributes(AttributeHandlerContext* context)
(uint8)attributeValue.unsignedInt); (uint8)attributeValue.unsignedInt);
break; break;
case B_HPKG_PACKAGE_ATTRIBUTE_VERSION_MAJOR: case HPKG_PACKAGE_ATTRIBUTE_VERSION_MAJOR:
error = _ParsePackageVersion(handlerValue.version, error = _ParsePackageVersion(handlerValue.version,
attributeValue.string); attributeValue.string);
if (error != B_OK) if (error != B_OK)
@@ -1169,17 +1169,17 @@ PackageReaderImpl::_ParsePackageAttributes(AttributeHandlerContext* context)
handlerValue.attributeIndex = B_PACKAGE_INFO_VERSION; handlerValue.attributeIndex = B_PACKAGE_INFO_VERSION;
break; break;
case B_HPKG_PACKAGE_ATTRIBUTE_COPYRIGHT: case HPKG_PACKAGE_ATTRIBUTE_COPYRIGHT:
handlerValue.SetTo(B_PACKAGE_INFO_COPYRIGHTS, handlerValue.SetTo(B_PACKAGE_INFO_COPYRIGHTS,
attributeValue.string); attributeValue.string);
break; break;
case B_HPKG_PACKAGE_ATTRIBUTE_LICENSE: case HPKG_PACKAGE_ATTRIBUTE_LICENSE:
handlerValue.SetTo(B_PACKAGE_INFO_LICENSES, handlerValue.SetTo(B_PACKAGE_INFO_LICENSES,
attributeValue.string); attributeValue.string);
break; break;
case B_HPKG_PACKAGE_ATTRIBUTE_PROVIDES_TYPE: case HPKG_PACKAGE_ATTRIBUTE_PROVIDES_TYPE:
error = _ParsePackageProvides(handlerValue.resolvable, error = _ParsePackageProvides(handlerValue.resolvable,
(BPackageResolvableType)attributeValue.unsignedInt); (BPackageResolvableType)attributeValue.unsignedInt);
if (error != B_OK) if (error != B_OK)
@@ -1187,7 +1187,7 @@ PackageReaderImpl::_ParsePackageAttributes(AttributeHandlerContext* context)
handlerValue.attributeIndex = B_PACKAGE_INFO_PROVIDES; handlerValue.attributeIndex = B_PACKAGE_INFO_PROVIDES;
break; break;
case B_HPKG_PACKAGE_ATTRIBUTE_REQUIRES: case HPKG_PACKAGE_ATTRIBUTE_REQUIRES:
error = _ParsePackageResolvableExpression( error = _ParsePackageResolvableExpression(
handlerValue.resolvableExpression, attributeValue.string, handlerValue.resolvableExpression, attributeValue.string,
hasChildren); hasChildren);
@@ -1196,7 +1196,7 @@ PackageReaderImpl::_ParsePackageAttributes(AttributeHandlerContext* context)
handlerValue.attributeIndex = B_PACKAGE_INFO_REQUIRES; handlerValue.attributeIndex = B_PACKAGE_INFO_REQUIRES;
break; break;
case B_HPKG_PACKAGE_ATTRIBUTE_SUPPLEMENTS: case HPKG_PACKAGE_ATTRIBUTE_SUPPLEMENTS:
error = _ParsePackageResolvableExpression( error = _ParsePackageResolvableExpression(
handlerValue.resolvableExpression, attributeValue.string, handlerValue.resolvableExpression, attributeValue.string,
hasChildren); hasChildren);
@@ -1205,7 +1205,7 @@ PackageReaderImpl::_ParsePackageAttributes(AttributeHandlerContext* context)
handlerValue.attributeIndex = B_PACKAGE_INFO_SUPPLEMENTS; handlerValue.attributeIndex = B_PACKAGE_INFO_SUPPLEMENTS;
break; break;
case B_HPKG_PACKAGE_ATTRIBUTE_CONFLICTS: case HPKG_PACKAGE_ATTRIBUTE_CONFLICTS:
error = _ParsePackageResolvableExpression( error = _ParsePackageResolvableExpression(
handlerValue.resolvableExpression, attributeValue.string, handlerValue.resolvableExpression, attributeValue.string,
hasChildren); hasChildren);
@@ -1214,7 +1214,7 @@ PackageReaderImpl::_ParsePackageAttributes(AttributeHandlerContext* context)
handlerValue.attributeIndex = B_PACKAGE_INFO_CONFLICTS; handlerValue.attributeIndex = B_PACKAGE_INFO_CONFLICTS;
break; break;
case B_HPKG_PACKAGE_ATTRIBUTE_FRESHENS: case HPKG_PACKAGE_ATTRIBUTE_FRESHENS:
error = _ParsePackageResolvableExpression( error = _ParsePackageResolvableExpression(
handlerValue.resolvableExpression, attributeValue.string, handlerValue.resolvableExpression, attributeValue.string,
hasChildren); hasChildren);
@@ -1223,7 +1223,7 @@ PackageReaderImpl::_ParsePackageAttributes(AttributeHandlerContext* context)
handlerValue.attributeIndex = B_PACKAGE_INFO_FRESHENS; handlerValue.attributeIndex = B_PACKAGE_INFO_FRESHENS;
break; break;
case B_HPKG_PACKAGE_ATTRIBUTE_REPLACES: case HPKG_PACKAGE_ATTRIBUTE_REPLACES:
handlerValue.SetTo(B_PACKAGE_INFO_REPLACES, handlerValue.SetTo(B_PACKAGE_INFO_REPLACES,
attributeValue.string); attributeValue.string);
break; break;
@@ -1261,7 +1261,7 @@ PackageReaderImpl::_ParsePackageVersion(BPackageVersionData& _version,
error = _ReadPackageAttribute(id, value); error = _ReadPackageAttribute(id, value);
if (error != B_OK) if (error != B_OK)
return error; return error;
if (id != B_HPKG_PACKAGE_ATTRIBUTE_VERSION_MAJOR) { if (id != HPKG_PACKAGE_ATTRIBUTE_VERSION_MAJOR) {
fErrorOutput->PrintError("Error: Invalid package attribute section:" fErrorOutput->PrintError("Error: Invalid package attribute section:"
" Invalid package version, expected major\n"); " Invalid package version, expected major\n");
return B_BAD_DATA; return B_BAD_DATA;
@@ -1274,7 +1274,7 @@ PackageReaderImpl::_ParsePackageVersion(BPackageVersionData& _version,
error = _ReadPackageAttribute(id, value); error = _ReadPackageAttribute(id, value);
if (error != B_OK) if (error != B_OK)
return error; return error;
if (id != B_HPKG_PACKAGE_ATTRIBUTE_VERSION_MINOR) { if (id != HPKG_PACKAGE_ATTRIBUTE_VERSION_MINOR) {
fErrorOutput->PrintError("Error: Invalid package attribute section:" fErrorOutput->PrintError("Error: Invalid package attribute section:"
" Invalid package version, expected minor\n"); " Invalid package version, expected minor\n");
return B_BAD_DATA; return B_BAD_DATA;
@@ -1285,7 +1285,7 @@ PackageReaderImpl::_ParsePackageVersion(BPackageVersionData& _version,
error = _ReadPackageAttribute(id, value); error = _ReadPackageAttribute(id, value);
if (error != B_OK) if (error != B_OK)
return error; return error;
if (id != B_HPKG_PACKAGE_ATTRIBUTE_VERSION_MICRO) { if (id != HPKG_PACKAGE_ATTRIBUTE_VERSION_MICRO) {
fErrorOutput->PrintError("Error: Invalid package attribute section:" fErrorOutput->PrintError("Error: Invalid package attribute section:"
" Invalid package version, expected micro\n"); " Invalid package version, expected micro\n");
return B_BAD_DATA; return B_BAD_DATA;
@@ -1296,7 +1296,7 @@ PackageReaderImpl::_ParsePackageVersion(BPackageVersionData& _version,
error = _ReadPackageAttribute(id, value); error = _ReadPackageAttribute(id, value);
if (error != B_OK) if (error != B_OK)
return error; return error;
if (id != B_HPKG_PACKAGE_ATTRIBUTE_VERSION_RELEASE) { if (id != HPKG_PACKAGE_ATTRIBUTE_VERSION_RELEASE) {
fErrorOutput->PrintError("Error: Invalid package attribute section:" fErrorOutput->PrintError("Error: Invalid package attribute section:"
" Invalid package version, expected release\n"); " Invalid package version, expected release\n");
return B_BAD_DATA; return B_BAD_DATA;
@@ -1327,7 +1327,7 @@ PackageReaderImpl::_ParsePackageProvides(BPackageResolvableData& _resolvable,
status_t error = _ReadPackageAttribute(id, value, &hasChildren); status_t error = _ReadPackageAttribute(id, value, &hasChildren);
if (error != B_OK) if (error != B_OK)
return error; return error;
if (id != B_HPKG_PACKAGE_ATTRIBUTE_PROVIDES) { if (id != HPKG_PACKAGE_ATTRIBUTE_PROVIDES) {
fErrorOutput->PrintError("Error: Invalid package attribute section: " fErrorOutput->PrintError("Error: Invalid package attribute section: "
"Invalid package provides, expected name of resolvable\n"); "Invalid package provides, expected name of resolvable\n");
return B_BAD_DATA; return B_BAD_DATA;
@@ -1372,7 +1372,7 @@ PackageReaderImpl::_ParsePackageResolvableExpression(
status_t error = _ReadPackageAttribute(id, value); status_t error = _ReadPackageAttribute(id, value);
if (error != B_OK) if (error != B_OK)
return error; return error;
if (id != B_HPKG_PACKAGE_ATTRIBUTE_RESOLVABLE_OPERATOR) { if (id != HPKG_PACKAGE_ATTRIBUTE_RESOLVABLE_OPERATOR) {
fErrorOutput->PrintError("Error: Invalid package attribute section:" fErrorOutput->PrintError("Error: Invalid package attribute section:"
" Invalid package resolvable expression, expected operator\n"); " Invalid package resolvable expression, expected operator\n");
return B_BAD_DATA; return B_BAD_DATA;
@@ -1419,7 +1419,7 @@ PackageReaderImpl::_ReadPackageAttribute(uint8& _id, AttributeValue& _value,
if (tag != 0) { if (tag != 0) {
// get the type // get the type
uint16 type = B_HPKG_PACKAGE_ATTRIBUTE_TAG_TYPE(tag); uint16 type = HPKG_PACKAGE_ATTRIBUTE_TAG_TYPE(tag);
if (type >= B_HPKG_ATTRIBUTE_TYPE_ENUM_COUNT) { if (type >= B_HPKG_ATTRIBUTE_TYPE_ENUM_COUNT) {
fErrorOutput->PrintError("Error: Invalid package attribute " fErrorOutput->PrintError("Error: Invalid package attribute "
"section: attribute type %d not supported!\n", type); "section: attribute type %d not supported!\n", type);
@@ -1428,12 +1428,12 @@ PackageReaderImpl::_ReadPackageAttribute(uint8& _id, AttributeValue& _value,
// get the value // get the value
error = _ReadAttributeValue(type, error = _ReadAttributeValue(type,
B_HPKG_PACKAGE_ATTRIBUTE_TAG_ENCODING(tag), _value); HPKG_PACKAGE_ATTRIBUTE_TAG_ENCODING(tag), _value);
if (error != B_OK) if (error != B_OK)
return error; return error;
_id = B_HPKG_PACKAGE_ATTRIBUTE_TAG_ID(tag); _id = HPKG_PACKAGE_ATTRIBUTE_TAG_ID(tag);
if (_id >= B_HPKG_PACKAGE_ATTRIBUTE_ENUM_COUNT) { if (_id >= HPKG_PACKAGE_ATTRIBUTE_ENUM_COUNT) {
fErrorOutput->PrintError("Error: Invalid package attribute section: " fErrorOutput->PrintError("Error: Invalid package attribute section: "
"attribute id %d not supported!\n", _id); "attribute id %d not supported!\n", _id);
return B_BAD_DATA; return B_BAD_DATA;
@@ -1441,7 +1441,7 @@ PackageReaderImpl::_ReadPackageAttribute(uint8& _id, AttributeValue& _value,
} }
if (_hasChildren != NULL) if (_hasChildren != NULL)
*_hasChildren = B_HPKG_PACKAGE_ATTRIBUTE_TAG_HAS_CHILDREN(tag); *_hasChildren = HPKG_PACKAGE_ATTRIBUTE_TAG_HAS_CHILDREN(tag);
if (_tag != NULL) if (_tag != NULL)
*_tag = tag; *_tag = tag;
src/kits/package/hpkg/PackageWriterImpl.cpp
+51 -51
View File
@@ -990,7 +990,7 @@ PackageWriterImpl::_WriteAttributeChildren(Attribute* attribute)
// write tag // write tag
uint8 encoding = child->value.PreferredEncoding(); uint8 encoding = child->value.PreferredEncoding();
_WriteUnsignedLEB128(B_HPKG_ATTRIBUTE_TAG_COMPOSE(type->index, _WriteUnsignedLEB128(HPKG_ATTRIBUTE_TAG_COMPOSE(type->index,
encoding, !child->children.IsEmpty())); encoding, !child->children.IsEmpty()));
// write value // write value
@@ -1015,38 +1015,38 @@ PackageWriterImpl::_WritePackageAttributes(hpkg_header& header)
zlibWriter.Init(); zlibWriter.Init();
// name // name
_WriteUnsignedLEB128(B_HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE( _WriteUnsignedLEB128(HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE(
B_HPKG_PACKAGE_ATTRIBUTE_NAME, B_HPKG_ATTRIBUTE_TYPE_STRING, HPKG_PACKAGE_ATTRIBUTE_NAME, B_HPKG_ATTRIBUTE_TYPE_STRING,
B_HPKG_ATTRIBUTE_ENCODING_STRING_INLINE, 0)); B_HPKG_ATTRIBUTE_ENCODING_STRING_INLINE, 0));
_WriteString(fPackageInfo.Name().String()); _WriteString(fPackageInfo.Name().String());
// summary // summary
_WriteUnsignedLEB128(B_HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE( _WriteUnsignedLEB128(HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE(
B_HPKG_PACKAGE_ATTRIBUTE_SUMMARY, B_HPKG_ATTRIBUTE_TYPE_STRING, HPKG_PACKAGE_ATTRIBUTE_SUMMARY, B_HPKG_ATTRIBUTE_TYPE_STRING,
B_HPKG_ATTRIBUTE_ENCODING_STRING_INLINE, 0)); B_HPKG_ATTRIBUTE_ENCODING_STRING_INLINE, 0));
_WriteString(fPackageInfo.Summary().String()); _WriteString(fPackageInfo.Summary().String());
// description // description
_WriteUnsignedLEB128(B_HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE( _WriteUnsignedLEB128(HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE(
B_HPKG_PACKAGE_ATTRIBUTE_DESCRIPTION, B_HPKG_ATTRIBUTE_TYPE_STRING, HPKG_PACKAGE_ATTRIBUTE_DESCRIPTION, B_HPKG_ATTRIBUTE_TYPE_STRING,
B_HPKG_ATTRIBUTE_ENCODING_STRING_INLINE, 0)); B_HPKG_ATTRIBUTE_ENCODING_STRING_INLINE, 0));
_WriteString(fPackageInfo.Description().String()); _WriteString(fPackageInfo.Description().String());
// vendor // vendor
_WriteUnsignedLEB128(B_HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE( _WriteUnsignedLEB128(HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE(
B_HPKG_PACKAGE_ATTRIBUTE_VENDOR, B_HPKG_ATTRIBUTE_TYPE_STRING, HPKG_PACKAGE_ATTRIBUTE_VENDOR, B_HPKG_ATTRIBUTE_TYPE_STRING,
B_HPKG_ATTRIBUTE_ENCODING_STRING_INLINE, 0)); B_HPKG_ATTRIBUTE_ENCODING_STRING_INLINE, 0));
_WriteString(fPackageInfo.Vendor().String()); _WriteString(fPackageInfo.Vendor().String());
// packager // packager
_WriteUnsignedLEB128(B_HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE( _WriteUnsignedLEB128(HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE(
B_HPKG_PACKAGE_ATTRIBUTE_PACKAGER, B_HPKG_ATTRIBUTE_TYPE_STRING, HPKG_PACKAGE_ATTRIBUTE_PACKAGER, B_HPKG_ATTRIBUTE_TYPE_STRING,
B_HPKG_ATTRIBUTE_ENCODING_STRING_INLINE, 0)); B_HPKG_ATTRIBUTE_ENCODING_STRING_INLINE, 0));
_WriteString(fPackageInfo.Packager().String()); _WriteString(fPackageInfo.Packager().String());
// architecture // architecture
_WriteUnsignedLEB128(B_HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE( _WriteUnsignedLEB128(HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE(
B_HPKG_PACKAGE_ATTRIBUTE_ARCHITECTURE, B_HPKG_ATTRIBUTE_TYPE_UINT, HPKG_PACKAGE_ATTRIBUTE_ARCHITECTURE, B_HPKG_ATTRIBUTE_TYPE_UINT,
B_HPKG_ATTRIBUTE_ENCODING_INT_8_BIT, 0)); B_HPKG_ATTRIBUTE_ENCODING_INT_8_BIT, 0));
_Write<uint8>(fPackageInfo.Architecture()); _Write<uint8>(fPackageInfo.Architecture());
@@ -1056,8 +1056,8 @@ PackageWriterImpl::_WritePackageAttributes(hpkg_header& header)
// copyright list // copyright list
const BObjectList<BString>& copyrightList = fPackageInfo.CopyrightList(); const BObjectList<BString>& copyrightList = fPackageInfo.CopyrightList();
for (int i = 0; i < copyrightList.CountItems(); ++i) { for (int i = 0; i < copyrightList.CountItems(); ++i) {
_WriteUnsignedLEB128(B_HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE( _WriteUnsignedLEB128(HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE(
B_HPKG_PACKAGE_ATTRIBUTE_COPYRIGHT, B_HPKG_ATTRIBUTE_TYPE_STRING, HPKG_PACKAGE_ATTRIBUTE_COPYRIGHT, B_HPKG_ATTRIBUTE_TYPE_STRING,
B_HPKG_ATTRIBUTE_ENCODING_STRING_INLINE, 0)); B_HPKG_ATTRIBUTE_ENCODING_STRING_INLINE, 0));
_WriteString(copyrightList.ItemAt(i)->String()); _WriteString(copyrightList.ItemAt(i)->String());
} }
@@ -1065,8 +1065,8 @@ PackageWriterImpl::_WritePackageAttributes(hpkg_header& header)
// license list // license list
const BObjectList<BString>& licenseList = fPackageInfo.LicenseList(); const BObjectList<BString>& licenseList = fPackageInfo.LicenseList();
for (int i = 0; i < licenseList.CountItems(); ++i) { for (int i = 0; i < licenseList.CountItems(); ++i) {
_WriteUnsignedLEB128(B_HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE( _WriteUnsignedLEB128(HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE(
B_HPKG_PACKAGE_ATTRIBUTE_LICENSE, B_HPKG_ATTRIBUTE_TYPE_STRING, HPKG_PACKAGE_ATTRIBUTE_LICENSE, B_HPKG_ATTRIBUTE_TYPE_STRING,
B_HPKG_ATTRIBUTE_ENCODING_STRING_INLINE, 0)); B_HPKG_ATTRIBUTE_ENCODING_STRING_INLINE, 0));
_WriteString(licenseList.ItemAt(i)->String()); _WriteString(licenseList.ItemAt(i)->String());
} }
@@ -1077,12 +1077,12 @@ PackageWriterImpl::_WritePackageAttributes(hpkg_header& header)
for (int i = 0; i < providesList.CountItems(); ++i) { for (int i = 0; i < providesList.CountItems(); ++i) {
BPackageResolvable* resolvable = providesList.ItemAt(i); BPackageResolvable* resolvable = providesList.ItemAt(i);
bool hasVersion = resolvable->Version().InitCheck() == B_OK; bool hasVersion = resolvable->Version().InitCheck() == B_OK;
_WriteUnsignedLEB128(B_HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE( _WriteUnsignedLEB128(HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE(
B_HPKG_PACKAGE_ATTRIBUTE_PROVIDES_TYPE, B_HPKG_ATTRIBUTE_TYPE_UINT, HPKG_PACKAGE_ATTRIBUTE_PROVIDES_TYPE, B_HPKG_ATTRIBUTE_TYPE_UINT,
B_HPKG_ATTRIBUTE_ENCODING_INT_8_BIT, 0)); B_HPKG_ATTRIBUTE_ENCODING_INT_8_BIT, 0));
_Write<uint8>((uint8)resolvable->Type()); _Write<uint8>((uint8)resolvable->Type());
_WriteUnsignedLEB128(B_HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE( _WriteUnsignedLEB128(HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE(
B_HPKG_PACKAGE_ATTRIBUTE_PROVIDES, B_HPKG_ATTRIBUTE_TYPE_STRING, HPKG_PACKAGE_ATTRIBUTE_PROVIDES, B_HPKG_ATTRIBUTE_TYPE_STRING,
B_HPKG_ATTRIBUTE_ENCODING_STRING_INLINE, hasVersion)); B_HPKG_ATTRIBUTE_ENCODING_STRING_INLINE, hasVersion));
_WriteString(resolvable->Name().String()); _WriteString(resolvable->Name().String());
if (hasVersion) { if (hasVersion) {
@@ -1093,25 +1093,25 @@ PackageWriterImpl::_WritePackageAttributes(hpkg_header& header)
// requires list // requires list
_WritePackageResolvableExpressionList(fPackageInfo.RequiresList(), _WritePackageResolvableExpressionList(fPackageInfo.RequiresList(),
B_HPKG_PACKAGE_ATTRIBUTE_REQUIRES); HPKG_PACKAGE_ATTRIBUTE_REQUIRES);
// supplements list // supplements list
_WritePackageResolvableExpressionList(fPackageInfo.SupplementsList(), _WritePackageResolvableExpressionList(fPackageInfo.SupplementsList(),
B_HPKG_PACKAGE_ATTRIBUTE_SUPPLEMENTS); HPKG_PACKAGE_ATTRIBUTE_SUPPLEMENTS);
// conflicts list // conflicts list
_WritePackageResolvableExpressionList(fPackageInfo.ConflictsList(), _WritePackageResolvableExpressionList(fPackageInfo.ConflictsList(),
B_HPKG_PACKAGE_ATTRIBUTE_CONFLICTS); HPKG_PACKAGE_ATTRIBUTE_CONFLICTS);
// freshens list // freshens list
_WritePackageResolvableExpressionList(fPackageInfo.FreshensList(), _WritePackageResolvableExpressionList(fPackageInfo.FreshensList(),
B_HPKG_PACKAGE_ATTRIBUTE_FRESHENS); HPKG_PACKAGE_ATTRIBUTE_FRESHENS);
// replaces list // replaces list
const BObjectList<BString>& replacesList = fPackageInfo.ReplacesList(); const BObjectList<BString>& replacesList = fPackageInfo.ReplacesList();
for (int i = 0; i < replacesList.CountItems(); ++i) { for (int i = 0; i < replacesList.CountItems(); ++i) {
_WriteUnsignedLEB128(B_HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE( _WriteUnsignedLEB128(HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE(
B_HPKG_PACKAGE_ATTRIBUTE_REPLACES, B_HPKG_ATTRIBUTE_TYPE_STRING, HPKG_PACKAGE_ATTRIBUTE_REPLACES, B_HPKG_ATTRIBUTE_TYPE_STRING,
B_HPKG_ATTRIBUTE_ENCODING_STRING_INLINE, 0)); B_HPKG_ATTRIBUTE_ENCODING_STRING_INLINE, 0));
_WriteString(replacesList.ItemAt(i)->String()); _WriteString(replacesList.ItemAt(i)->String());
} }
@@ -1139,20 +1139,20 @@ PackageWriterImpl::_WritePackageAttributes(hpkg_header& header)
void void
PackageWriterImpl::_WritePackageVersion(const BPackageVersion& version) PackageWriterImpl::_WritePackageVersion(const BPackageVersion& version)
{ {
_WriteUnsignedLEB128(B_HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE( _WriteUnsignedLEB128(HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE(
B_HPKG_PACKAGE_ATTRIBUTE_VERSION_MAJOR, B_HPKG_ATTRIBUTE_TYPE_STRING, HPKG_PACKAGE_ATTRIBUTE_VERSION_MAJOR, B_HPKG_ATTRIBUTE_TYPE_STRING,
B_HPKG_ATTRIBUTE_ENCODING_STRING_INLINE, 0)); B_HPKG_ATTRIBUTE_ENCODING_STRING_INLINE, 0));
_WriteString(version.Major()); _WriteString(version.Major());
_WriteUnsignedLEB128(B_HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE( _WriteUnsignedLEB128(HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE(
B_HPKG_PACKAGE_ATTRIBUTE_VERSION_MINOR, B_HPKG_ATTRIBUTE_TYPE_STRING, HPKG_PACKAGE_ATTRIBUTE_VERSION_MINOR, B_HPKG_ATTRIBUTE_TYPE_STRING,
B_HPKG_ATTRIBUTE_ENCODING_STRING_INLINE, 0)); B_HPKG_ATTRIBUTE_ENCODING_STRING_INLINE, 0));
_WriteString(version.Minor()); _WriteString(version.Minor());
_WriteUnsignedLEB128(B_HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE( _WriteUnsignedLEB128(HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE(
B_HPKG_PACKAGE_ATTRIBUTE_VERSION_MICRO, B_HPKG_ATTRIBUTE_TYPE_STRING, HPKG_PACKAGE_ATTRIBUTE_VERSION_MICRO, B_HPKG_ATTRIBUTE_TYPE_STRING,
B_HPKG_ATTRIBUTE_ENCODING_STRING_INLINE, 0)); B_HPKG_ATTRIBUTE_ENCODING_STRING_INLINE, 0));
_WriteString(version.Micro()); _WriteString(version.Micro());
_WriteUnsignedLEB128(B_HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE( _WriteUnsignedLEB128(HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE(
B_HPKG_PACKAGE_ATTRIBUTE_VERSION_RELEASE, B_HPKG_ATTRIBUTE_TYPE_UINT, HPKG_PACKAGE_ATTRIBUTE_VERSION_RELEASE, B_HPKG_ATTRIBUTE_TYPE_UINT,
B_HPKG_ATTRIBUTE_ENCODING_INT_8_BIT, 0)); B_HPKG_ATTRIBUTE_ENCODING_INT_8_BIT, 0));
_Write<uint8>(version.Release()); _Write<uint8>(version.Release());
} }
@@ -1165,13 +1165,13 @@ PackageWriterImpl::_WritePackageResolvableExpressionList(
for (int i = 0; i < list.CountItems(); ++i) { for (int i = 0; i < list.CountItems(); ++i) {
BPackageResolvableExpression* resolvableExpr = list.ItemAt(i); BPackageResolvableExpression* resolvableExpr = list.ItemAt(i);
bool hasVersion = resolvableExpr->Version().InitCheck() == B_OK; bool hasVersion = resolvableExpr->Version().InitCheck() == B_OK;
_WriteUnsignedLEB128(B_HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE( _WriteUnsignedLEB128(HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE(
id, B_HPKG_ATTRIBUTE_TYPE_STRING, id, B_HPKG_ATTRIBUTE_TYPE_STRING,
B_HPKG_ATTRIBUTE_ENCODING_STRING_INLINE, hasVersion)); B_HPKG_ATTRIBUTE_ENCODING_STRING_INLINE, hasVersion));
_WriteString(resolvableExpr->Name().String()); _WriteString(resolvableExpr->Name().String());
if (hasVersion) { if (hasVersion) {
_WriteUnsignedLEB128(B_HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE( _WriteUnsignedLEB128(HPKG_PACKAGE_ATTRIBUTE_TAG_COMPOSE(
B_HPKG_PACKAGE_ATTRIBUTE_RESOLVABLE_OPERATOR, HPKG_PACKAGE_ATTRIBUTE_RESOLVABLE_OPERATOR,
B_HPKG_ATTRIBUTE_TYPE_UINT, B_HPKG_ATTRIBUTE_ENCODING_INT_8_BIT, B_HPKG_ATTRIBUTE_TYPE_UINT, B_HPKG_ATTRIBUTE_ENCODING_INT_8_BIT,
0)); 0));
_Write<uint8>(resolvableExpr->Operator()); _Write<uint8>(resolvableExpr->Operator());
@@ -1339,19 +1339,19 @@ PackageWriterImpl::_AddEntry(int dirFD, Entry* entry, const char* fileName,
// add attribute entry // add attribute entry
Attribute* entryAttribute = _AddStringAttribute( Attribute* entryAttribute = _AddStringAttribute(
B_HPKG_ATTRIBUTE_NAME_DIRECTORY_ENTRY, fileName); HPKG_ATTRIBUTE_NAME_DIRECTORY_ENTRY, fileName);
Stacker<Attribute> entryAttributeStacker(fTopAttribute, entryAttribute); Stacker<Attribute> entryAttributeStacker(fTopAttribute, entryAttribute);
// add stat data // add stat data
if (fileType != B_HPKG_DEFAULT_FILE_TYPE) if (fileType != B_HPKG_DEFAULT_FILE_TYPE)
_AddAttribute(B_HPKG_ATTRIBUTE_NAME_FILE_TYPE, fileType); _AddAttribute(HPKG_ATTRIBUTE_NAME_FILE_TYPE, fileType);
if (defaultPermissions != uint32(st.st_mode & ALLPERMS)) { if (defaultPermissions != uint32(st.st_mode & ALLPERMS)) {
_AddAttribute(B_HPKG_ATTRIBUTE_NAME_FILE_PERMISSIONS, _AddAttribute(HPKG_ATTRIBUTE_NAME_FILE_PERMISSIONS,
uint32(st.st_mode & ALLPERMS)); uint32(st.st_mode & ALLPERMS));
} }
_AddAttribute(B_HPKG_ATTRIBUTE_NAME_FILE_ATIME, uint32(st.st_atime)); _AddAttribute(HPKG_ATTRIBUTE_NAME_FILE_ATIME, uint32(st.st_atime));
_AddAttribute(B_HPKG_ATTRIBUTE_NAME_FILE_MTIME, uint32(st.st_mtime)); _AddAttribute(HPKG_ATTRIBUTE_NAME_FILE_MTIME, uint32(st.st_mtime));
_AddAttribute(B_HPKG_ATTRIBUTE_NAME_FILE_CRTIME, uint32(st.st_crtime)); _AddAttribute(HPKG_ATTRIBUTE_NAME_FILE_CRTIME, uint32(st.st_crtime));
// TODO: File user/group! // TODO: File user/group!
// add file data/symlink path // add file data/symlink path
@@ -1375,7 +1375,7 @@ PackageWriterImpl::_AddEntry(int dirFD, Entry* entry, const char* fileName,
} }
path[bytesRead] = '\0'; path[bytesRead] = '\0';
_AddStringAttribute(B_HPKG_ATTRIBUTE_NAME_SYMLINK_PATH, path); _AddStringAttribute(HPKG_ATTRIBUTE_NAME_SYMLINK_PATH, path);
} }
// add attributes // add attributes
@@ -1393,12 +1393,12 @@ PackageWriterImpl::_AddEntry(int dirFD, Entry* entry, const char* fileName,
// create attribute entry // create attribute entry
Attribute* attributeAttribute = _AddStringAttribute( Attribute* attributeAttribute = _AddStringAttribute(
B_HPKG_ATTRIBUTE_NAME_FILE_ATTRIBUTE, entry->d_name); HPKG_ATTRIBUTE_NAME_FILE_ATTRIBUTE, entry->d_name);
Stacker<Attribute> attributeAttributeStacker(fTopAttribute, Stacker<Attribute> attributeAttributeStacker(fTopAttribute,
attributeAttribute); attributeAttribute);
// add type // add type
_AddAttribute(B_HPKG_ATTRIBUTE_NAME_FILE_ATTRIBUTE_TYPE, _AddAttribute(HPKG_ATTRIBUTE_NAME_FILE_ATTRIBUTE_TYPE,
(uint32)attrInfo.type); (uint32)attrInfo.type);
// add data // add data
@@ -1547,7 +1547,7 @@ PackageWriterImpl::_AddData(BDataReader& dataReader, off_t size)
return error; return error;
} }
_AddDataAttribute(B_HPKG_ATTRIBUTE_NAME_DATA, size, buffer); _AddDataAttribute(HPKG_ATTRIBUTE_NAME_DATA, size, buffer);
return B_OK; return B_OK;
} }
@@ -1571,14 +1571,14 @@ PackageWriterImpl::_AddData(BDataReader& dataReader, off_t size)
fHeapEnd = dataOffset + compressedSize; fHeapEnd = dataOffset + compressedSize;
// add data attribute // add data attribute
Attribute* dataAttribute = _AddDataAttribute(B_HPKG_ATTRIBUTE_NAME_DATA, Attribute* dataAttribute = _AddDataAttribute(HPKG_ATTRIBUTE_NAME_DATA,
compressedSize, dataOffset - fHeapOffset); compressedSize, dataOffset - fHeapOffset);
Stacker<Attribute> attributeAttributeStacker(fTopAttribute, dataAttribute); Stacker<Attribute> attributeAttributeStacker(fTopAttribute, dataAttribute);
// if compressed, add compression attributes // if compressed, add compression attributes
if (compression != B_HPKG_COMPRESSION_NONE) { if (compression != B_HPKG_COMPRESSION_NONE) {
_AddAttribute(B_HPKG_ATTRIBUTE_NAME_DATA_COMPRESSION, compression); _AddAttribute(HPKG_ATTRIBUTE_NAME_DATA_COMPRESSION, compression);
_AddAttribute(B_HPKG_ATTRIBUTE_NAME_DATA_SIZE, (uint64)size); _AddAttribute(HPKG_ATTRIBUTE_NAME_DATA_SIZE, (uint64)size);
// uncompressed size // uncompressed size
} }