#include "PackageInfoParser.h"
#include <ctype.h>
#include <stdint.h>
#include <stdlib.h>
#include <algorithm>
#include <string>
#include <Url.h>
namespace BPackageKit {
BPackageInfo::ParseErrorListener::~ParseErrorListener()
{
}
BPackageInfo::Parser::Parser(ParseErrorListener* listener)
:
fListener(listener),
fPos(NULL)
{
}
status_t
BPackageInfo::Parser::Parse(const BString& packageInfoString,
BPackageInfo* packageInfo)
{
if (packageInfo == NULL)
return B_BAD_VALUE;
fPos = packageInfoString.String();
try {
_Parse(packageInfo);
} catch (const ParseError& error) {
if (fListener != NULL) {
int line = 1;
int inLineOffset;
int32 offset = error.pos - packageInfoString.String();
int32 newlinePos = packageInfoString.FindLast('\n', offset - 1);
if (newlinePos < 0)
inLineOffset = offset;
else {
inLineOffset = offset - newlinePos - 1;
do {
line++;
newlinePos = packageInfoString.FindLast('\n',
newlinePos - 1);
} while (newlinePos >= 0);
}
int column = 0;
for (int i = 0; i < inLineOffset; i++) {
column++;
if (error.pos[i - inLineOffset] == '\t')
column = (column + 3) / 4 * 4;
}
fListener->OnError(error.message, line, column + 1);
}
return B_BAD_DATA;
} catch (const std::bad_alloc& e) {
if (fListener != NULL)
fListener->OnError("out of memory", 0, 0);
return B_NO_MEMORY;
}
return B_OK;
}
status_t
BPackageInfo::Parser::ParseVersion(const BString& versionString,
bool revisionIsOptional, BPackageVersion& _version)
{
fPos = versionString.String();
try {
Token token(TOKEN_STRING, fPos, versionString.Length());
_ParseVersionValue(token, &_version, revisionIsOptional);
} catch (const ParseError& error) {
if (fListener != NULL) {
int32 offset = error.pos - versionString.String();
fListener->OnError(error.message, 1, offset);
}
return B_BAD_DATA;
} catch (const std::bad_alloc& e) {
if (fListener != NULL)
fListener->OnError("out of memory", 0, 0);
return B_NO_MEMORY;
}
return B_OK;
}
status_t
BPackageInfo::Parser::ParseResolvable(const BString& expressionString,
BPackageResolvable& _expression)
{
fPos = expressionString.String();
try {
Token token(TOKEN_STRING, fPos, expressionString.Length());
_ParseResolvable(_NextToken(), _expression);
} catch (const ParseError& error) {
if (fListener != NULL) {
int32 offset = error.pos - expressionString.String();
fListener->OnError(error.message, 1, offset);
}
return B_BAD_DATA;
} catch (const std::bad_alloc& e) {
if (fListener != NULL)
fListener->OnError("out of memory", 0, 0);
return B_NO_MEMORY;
}
return B_OK;
}
status_t
BPackageInfo::Parser::ParseResolvableExpression(const BString& expressionString,
BPackageResolvableExpression& _expression)
{
fPos = expressionString.String();
try {
Token token(TOKEN_STRING, fPos, expressionString.Length());
_ParseResolvableExpression(_NextToken(), _expression, NULL);
} catch (const ParseError& error) {
if (fListener != NULL) {
int32 offset = error.pos - expressionString.String();
fListener->OnError(error.message, 1, offset);
}
return B_BAD_DATA;
} catch (const std::bad_alloc& e) {
if (fListener != NULL)
fListener->OnError("out of memory", 0, 0);
return B_NO_MEMORY;
}
return B_OK;
}
BPackageInfo::Parser::Token
BPackageInfo::Parser::_NextToken()
{
const char* itemSeparatorPos = NULL;
bool inComment = false;
while ((inComment && *fPos != '\0') || isspace(*fPos) || *fPos == ';'
|| *fPos == '#' || *fPos == '\\') {
if (*fPos == '#') {
inComment = true;
} else if (!inComment && *fPos == '\\') {
if (fPos[1] != '\n')
break;
fPos++;
} else if (*fPos == '\n') {
itemSeparatorPos = fPos;
inComment = false;
} else if (!inComment && *fPos == ';')
itemSeparatorPos = fPos;
fPos++;
}
if (itemSeparatorPos != NULL) {
return Token(TOKEN_ITEM_SEPARATOR, itemSeparatorPos);
}
const char* tokenPos = fPos;
switch (*fPos) {
case '\0':
return Token(TOKEN_EOF, fPos);
case '{':
fPos++;
return Token(TOKEN_OPEN_BRACE, tokenPos);
case '}':
fPos++;
return Token(TOKEN_CLOSE_BRACE, tokenPos);
case '<':
fPos++;
if (*fPos == '=') {
fPos++;
return Token(TOKEN_OPERATOR_LESS_EQUAL, tokenPos, 2);
}
return Token(TOKEN_OPERATOR_LESS, tokenPos, 1);
case '=':
fPos++;
if (*fPos == '=') {
fPos++;
return Token(TOKEN_OPERATOR_EQUAL, tokenPos, 2);
}
return Token(TOKEN_OPERATOR_ASSIGN, tokenPos, 1);
case '!':
if (fPos[1] == '=') {
fPos += 2;
return Token(TOKEN_OPERATOR_NOT_EQUAL, tokenPos, 2);
}
break;
case '>':
fPos++;
if (*fPos == '=') {
fPos++;
return Token(TOKEN_OPERATOR_GREATER_EQUAL, tokenPos, 2);
}
return Token(TOKEN_OPERATOR_GREATER, tokenPos, 1);
default:
{
std::string string;
char quoteChar = '\0';
for (; *fPos != '\0'; fPos++) {
char c = *fPos;
if (quoteChar != '\0') {
if (c == quoteChar) {
quoteChar = '\0';
continue;
}
if (c == '\\') {
c = *++fPos;
if (c == '\0') {
throw ParseError("unterminated quoted-string",
tokenPos);
}
if (c == 'n')
c = '\n';
else if (c == 't')
c = '\t';
}
string += c;
} else {
switch (c) {
case '"':
case '\'':
quoteChar = c;
continue;
case '{':
case '}':
case '<':
case '=':
case '!':
case '>':
break;
case '\\':
c = *++fPos;
if (c == '\0') {
throw ParseError("'\\' at end of string",
tokenPos);
}
string += c;
continue;
default:
if (isspace(c))
break;
string += c;
continue;
}
break;
}
}
return Token(TOKEN_STRING, tokenPos, fPos - tokenPos,
string.c_str());
}
}
BString error = BString("unknown token '") << *fPos << "' encountered";
throw ParseError(error.String(), fPos);
}
void
BPackageInfo::Parser::_RewindTo(const Token& token)
{
fPos = token.pos;
}
void
BPackageInfo::Parser::_ParseStringValue(BString* value, const char** _tokenPos)
{
Token string = _NextToken();
if (string.type != TOKEN_STRING)
throw ParseError("expected string", string.pos);
*value = string.text;
if (_tokenPos != NULL)
*_tokenPos = string.pos;
}
void
BPackageInfo::Parser::_ParseArchitectureValue(BPackageArchitecture* value)
{
Token arch = _NextToken();
if (arch.type == TOKEN_STRING) {
for (int i = 0; i < B_PACKAGE_ARCHITECTURE_ENUM_COUNT; ++i) {
if (arch.text.ICompare(BPackageInfo::kArchitectureNames[i]) == 0) {
*value = (BPackageArchitecture)i;
return;
}
}
}
BString error("architecture must be one of: [");
for (int i = 0; i < B_PACKAGE_ARCHITECTURE_ENUM_COUNT; ++i) {
if (i > 0)
error << ",";
error << BPackageInfo::kArchitectureNames[i];
}
error << "]";
throw ParseError(error, arch.pos);
}
void
BPackageInfo::Parser::_ParseVersionValue(BPackageVersion* value,
bool revisionIsOptional)
{
Token word = _NextToken();
_ParseVersionValue(word, value, revisionIsOptional);
}
void
BPackageInfo::Parser::_ParseVersionValue(Token& word, BPackageVersion* value,
bool revisionIsOptional)
{
if (word.type != TOKEN_STRING)
throw ParseError("expected string (a version)", word.pos);
uint32 revision = 0;
int32 dashPos = word.text.FindLast('-');
if (dashPos >= 0) {
char* end;
long long number = strtoll(word.text.String() + dashPos + 1, &end,
0);
if (*end != '\0' || number < 0 || number > UINT_MAX) {
throw ParseError("revision must be a number > 0 and < UINT_MAX",
word.pos + dashPos + 1);
}
revision = (uint32)number;
word.text.Truncate(dashPos);
}
if (revision == 0 && !revisionIsOptional) {
throw ParseError("expected revision number (-<number> suffix)",
word.pos + word.text.Length());
}
BString preRelease;
int32 tildePos = word.text.FindLast('~');
if (tildePos >= 0) {
word.text.CopyInto(preRelease, tildePos + 1,
word.text.Length() - tildePos - 1);
word.text.Truncate(tildePos);
if (preRelease.IsEmpty()) {
throw ParseError("invalid empty pre-release string",
word.pos + tildePos + 1);
}
int32 errorPos;
if (!_IsAlphaNumUnderscore(preRelease, ".", &errorPos)) {
throw ParseError("invalid character in pre-release string",
word.pos + tildePos + 1 + errorPos);
}
}
BString major;
BString minor;
BString micro;
int32 firstDotPos = word.text.FindFirst('.');
if (firstDotPos < 0)
major = word.text;
else {
word.text.CopyInto(major, 0, firstDotPos);
int32 secondDotPos = word.text.FindFirst('.', firstDotPos + 1);
if (secondDotPos == firstDotPos + 1)
throw ParseError("expected minor version", word.pos + secondDotPos);
if (secondDotPos < 0) {
word.text.CopyInto(minor, firstDotPos + 1, word.text.Length());
} else {
word.text.CopyInto(minor, firstDotPos + 1,
secondDotPos - (firstDotPos + 1));
word.text.CopyInto(micro, secondDotPos + 1, word.text.Length());
int32 errorPos;
if (!_IsAlphaNumUnderscore(micro, ".", &errorPos)) {
throw ParseError("invalid character in micro version string",
word.pos + secondDotPos + 1 + errorPos);
}
}
int32 errorPos;
if (!_IsAlphaNumUnderscore(minor, "", &errorPos)) {
throw ParseError("invalid character in minor version string",
word.pos + firstDotPos + 1 + errorPos);
}
}
int32 errorPos;
if (!_IsAlphaNumUnderscore(major, "", &errorPos)) {
throw ParseError("invalid character in major version string",
word.pos + errorPos);
}
value->SetTo(major, minor, micro, preRelease, revision);
}
void
BPackageInfo::Parser::_ParseResolvable(const Token& token,
BPackageResolvable& _value)
{
if (token.type != TOKEN_STRING) {
throw ParseError("expected word (a resolvable name)",
token.pos);
}
int32 errorPos;
if (!_IsValidResolvableName(token.text, &errorPos)) {
throw ParseError("invalid character in resolvable name",
token.pos + errorPos);
}
BPackageVersion version;
Token op = _NextToken();
if (op.type == TOKEN_OPERATOR_ASSIGN) {
_ParseVersionValue(&version, true);
} else if (op.type == TOKEN_ITEM_SEPARATOR
|| op.type == TOKEN_CLOSE_BRACE || op.type == TOKEN_EOF) {
_RewindTo(op);
} else
throw ParseError("expected '=', comma or '}'", op.pos);
BPackageVersion compatibleVersion;
Token compatible = _NextToken();
if (compatible.type == TOKEN_STRING
&& (compatible.text == "compat"
|| compatible.text == "compatible")) {
op = _NextToken();
if (op.type == TOKEN_OPERATOR_GREATER_EQUAL) {
_ParseVersionValue(&compatibleVersion, true);
} else
_RewindTo(compatible);
} else
_RewindTo(compatible);
_value.SetTo(token.text, version, compatibleVersion);
}
void
BPackageInfo::Parser::_ParseResolvableExpression(const Token& token,
BPackageResolvableExpression& _value, BString* _basePackage)
{
if (token.type != TOKEN_STRING) {
throw ParseError("expected word (a resolvable name)",
token.pos);
}
int32 errorPos;
if (!_IsValidResolvableName(token.text, &errorPos)) {
throw ParseError("invalid character in resolvable name",
token.pos + errorPos);
}
BPackageVersion version;
Token op = _NextToken();
BPackageResolvableOperator resolvableOperator;
if (op.type == TOKEN_OPERATOR_LESS
|| op.type == TOKEN_OPERATOR_LESS_EQUAL
|| op.type == TOKEN_OPERATOR_EQUAL
|| op.type == TOKEN_OPERATOR_NOT_EQUAL
|| op.type == TOKEN_OPERATOR_GREATER_EQUAL
|| op.type == TOKEN_OPERATOR_GREATER) {
_ParseVersionValue(&version, true);
if (_basePackage != NULL) {
Token base = _NextToken();
if (base.type == TOKEN_STRING && base.text == "base") {
if (!_basePackage->IsEmpty()) {
throw ParseError("multiple packages marked as base package",
token.pos);
}
*_basePackage = token.text;
} else
_RewindTo(base);
}
resolvableOperator = (BPackageResolvableOperator)
(op.type - TOKEN_OPERATOR_LESS);
} else if (op.type == TOKEN_ITEM_SEPARATOR
|| op.type == TOKEN_CLOSE_BRACE || op.type == TOKEN_EOF) {
_RewindTo(op);
resolvableOperator = B_PACKAGE_RESOLVABLE_OP_ENUM_COUNT;
} else {
throw ParseError(
"expected '<', '<=', '==', '!=', '>=', '>', comma or '}'",
op.pos);
}
_value.SetTo(token.text, resolvableOperator, version);
}
void
BPackageInfo::Parser::_ParseList(ListElementParser& elementParser,
bool allowSingleNonListElement)
{
Token openBracket = _NextToken();
if (openBracket.type != TOKEN_OPEN_BRACE) {
if (!allowSingleNonListElement)
throw ParseError("expected start of list ('{')", openBracket.pos);
elementParser(openBracket);
return;
}
while (true) {
Token token = _NextToken();
if (token.type == TOKEN_CLOSE_BRACE)
return;
if (token.type == TOKEN_ITEM_SEPARATOR)
continue;
elementParser(token);
}
}
void
BPackageInfo::Parser::_ParseStringList(BStringList* value,
bool requireResolvableName, bool convertToLowerCase,
StringValidator* stringValidator)
{
struct StringParser : public ListElementParser {
BStringList* value;
bool requireResolvableName;
bool convertToLowerCase;
StringValidator* stringValidator;
StringParser(BStringList* value, bool requireResolvableName,
bool convertToLowerCase, StringValidator* stringValidator)
:
value(value),
requireResolvableName(requireResolvableName),
convertToLowerCase(convertToLowerCase),
stringValidator(stringValidator)
{
}
virtual void operator()(const Token& token)
{
if (token.type != TOKEN_STRING)
throw ParseError("expected string", token.pos);
if (requireResolvableName) {
int32 errorPos;
if (!_IsValidResolvableName(token.text, &errorPos)) {
throw ParseError("invalid character in resolvable name",
token.pos + errorPos);
}
}
BString element(token.text);
if (convertToLowerCase)
element.ToLower();
if (stringValidator != NULL)
stringValidator->Validate(element, token.pos);
value->Add(element);
}
} stringParser(value, requireResolvableName, convertToLowerCase,
stringValidator);
_ParseList(stringParser, true);
}
uint32
BPackageInfo::Parser::_ParseFlags()
{
struct FlagParser : public ListElementParser {
uint32 flags;
FlagParser()
:
flags(0)
{
}
virtual void operator()(const Token& token)
{
if (token.type != TOKEN_STRING)
throw ParseError("expected word (a flag)", token.pos);
if (token.text.ICompare("approve_license") == 0)
flags |= B_PACKAGE_FLAG_APPROVE_LICENSE;
else if (token.text.ICompare("system_package") == 0)
flags |= B_PACKAGE_FLAG_SYSTEM_PACKAGE;
else {
throw ParseError(
"expected 'approve_license' or 'system_package'",
token.pos);
}
}
} flagParser;
_ParseList(flagParser, true);
return flagParser.flags;
}
void
BPackageInfo::Parser::_ParseResolvableList(
BObjectList<BPackageResolvable, true>* value)
{
struct ResolvableParser : public ListElementParser {
Parser& parser;
BObjectList<BPackageResolvable, true>* value;
ResolvableParser(Parser& parser_,
BObjectList<BPackageResolvable, true>* value_)
:
parser(parser_),
value(value_)
{
}
virtual void operator()(const Token& token)
{
BPackageResolvable expression;
parser._ParseResolvable(token, expression);
value->AddItem(new BPackageResolvable(expression));
}
} resolvableParser(*this, value);
_ParseList(resolvableParser, false);
}
void
BPackageInfo::Parser::_ParseResolvableExprList(
BObjectList<BPackageResolvableExpression, true>* value, BString* _basePackage)
{
struct ResolvableExpressionParser : public ListElementParser {
Parser& parser;
BObjectList<BPackageResolvableExpression, true>* value;
BString* basePackage;
ResolvableExpressionParser(Parser& parser,
BObjectList<BPackageResolvableExpression, true>* value,
BString* basePackage)
:
parser(parser),
value(value),
basePackage(basePackage)
{
}
virtual void operator()(const Token& token)
{
BPackageResolvableExpression expression;
parser._ParseResolvableExpression(token, expression, basePackage);
value->AddItem(new BPackageResolvableExpression(expression));
}
} resolvableExpressionParser(*this, value, _basePackage);
_ParseList(resolvableExpressionParser, false);
}
void
BPackageInfo::Parser::_ParseGlobalWritableFileInfos(
GlobalWritableFileInfoList* infos)
{
struct GlobalWritableFileInfoParser : public ListElementParser {
Parser& parser;
GlobalWritableFileInfoList* infos;
GlobalWritableFileInfoParser(Parser& parser,
GlobalWritableFileInfoList* infos)
:
parser(parser),
infos(infos)
{
}
virtual void operator()(const Token& token)
{
if (token.type != TOKEN_STRING) {
throw ParseError("expected string (a file path)",
token.pos);
}
BWritableFileUpdateType updateType
= B_WRITABLE_FILE_UPDATE_TYPE_ENUM_COUNT;
bool isDirectory = false;
Token nextToken = parser._NextToken();
if (nextToken.type == TOKEN_STRING
&& nextToken.text == "directory") {
isDirectory = true;
nextToken = parser._NextToken();
}
if (nextToken.type == TOKEN_STRING) {
const char* const* end = kWritableFileUpdateTypes
+ B_WRITABLE_FILE_UPDATE_TYPE_ENUM_COUNT;
const char* const* found = std::find(kWritableFileUpdateTypes,
end, nextToken.text);
if (found == end) {
throw ParseError(BString("expected an update type"),
nextToken.pos);
}
updateType = (BWritableFileUpdateType)(
found - kWritableFileUpdateTypes);
} else if (nextToken.type == TOKEN_ITEM_SEPARATOR
|| nextToken.type == TOKEN_CLOSE_BRACE) {
parser._RewindTo(nextToken);
} else {
throw ParseError(
"expected 'included', semicolon, new line or '}'",
nextToken.pos);
}
if (!infos->AddItem(new BGlobalWritableFileInfo(token.text,
updateType, isDirectory))) {
throw std::bad_alloc();
}
}
} resolvableExpressionParser(*this, infos);
_ParseList(resolvableExpressionParser, false);
}
void
BPackageInfo::Parser::_ParseUserSettingsFileInfos(
UserSettingsFileInfoList* infos)
{
struct UserSettingsFileInfoParser : public ListElementParser {
Parser& parser;
UserSettingsFileInfoList* infos;
UserSettingsFileInfoParser(Parser& parser,
UserSettingsFileInfoList* infos)
:
parser(parser),
infos(infos)
{
}
virtual void operator()(const Token& token)
{
if (token.type != TOKEN_STRING) {
throw ParseError("expected string (a settings file path)",
token.pos);
}
BString templatePath;
bool isDirectory = false;
Token nextToken = parser._NextToken();
if (nextToken.type == TOKEN_STRING
&& nextToken.text == "directory") {
isDirectory = true;
} else if (nextToken.type == TOKEN_STRING
&& nextToken.text == "template") {
nextToken = parser._NextToken();
if (nextToken.type != TOKEN_STRING) {
throw ParseError(
"expected string (a settings template file path)",
nextToken.pos);
}
templatePath = nextToken.text;
} else if (nextToken.type == TOKEN_ITEM_SEPARATOR
|| nextToken.type == TOKEN_CLOSE_BRACE) {
parser._RewindTo(nextToken);
} else {
throw ParseError(
"expected 'template', semicolon, new line or '}'",
nextToken.pos);
}
if (isDirectory
? !infos->AddItem(new BUserSettingsFileInfo(token.text, true))
: !infos->AddItem(new BUserSettingsFileInfo(token.text,
templatePath))) {
throw std::bad_alloc();
}
}
} resolvableExpressionParser(*this, infos);
_ParseList(resolvableExpressionParser, false);
}
void
BPackageInfo::Parser::_ParseUsers(UserList* users)
{
struct UserParser : public ListElementParser {
Parser& parser;
UserList* users;
UserParser(Parser& parser, UserList* users)
:
parser(parser),
users(users)
{
}
virtual void operator()(const Token& token)
{
if (token.type != TOKEN_STRING
|| !BUser::IsValidUserName(token.text)) {
throw ParseError("expected a user name", token.pos);
}
BString realName;
BString home;
BString shell;
BStringList groups;
for (;;) {
Token nextToken = parser._NextToken();
if (nextToken.type != TOKEN_STRING) {
parser._RewindTo(nextToken);
break;
}
if (nextToken.text == "real-name") {
nextToken = parser._NextToken();
if (nextToken.type != TOKEN_STRING) {
throw ParseError("expected string (a user real name)",
nextToken.pos);
}
realName = nextToken.text;
} else if (nextToken.text == "home") {
nextToken = parser._NextToken();
if (nextToken.type != TOKEN_STRING) {
throw ParseError("expected string (a home path)",
nextToken.pos);
}
home = nextToken.text;
} else if (nextToken.text == "shell") {
nextToken = parser._NextToken();
if (nextToken.type != TOKEN_STRING) {
throw ParseError("expected string (a shell path)",
nextToken.pos);
}
shell = nextToken.text;
} else if (nextToken.text == "groups") {
for (;;) {
nextToken = parser._NextToken();
if (nextToken.type == TOKEN_STRING
&& BUser::IsValidUserName(nextToken.text)) {
if (!groups.Add(nextToken.text))
throw std::bad_alloc();
} else if (nextToken.type == TOKEN_ITEM_SEPARATOR
|| nextToken.type == TOKEN_CLOSE_BRACE) {
parser._RewindTo(nextToken);
break;
} else {
throw ParseError("expected a group name",
nextToken.pos);
}
}
break;
} else {
throw ParseError(
"expected 'real-name', 'home', 'shell', or 'groups'",
nextToken.pos);
}
}
BString templatePath;
Token nextToken = parser._NextToken();
if (nextToken.type == TOKEN_STRING
&& nextToken.text == "template") {
nextToken = parser._NextToken();
if (nextToken.type != TOKEN_STRING) {
throw ParseError(
"expected string (a settings template file path)",
nextToken.pos);
}
templatePath = nextToken.text;
} else if (nextToken.type == TOKEN_ITEM_SEPARATOR
|| nextToken.type == TOKEN_CLOSE_BRACE) {
parser._RewindTo(nextToken);
} else {
throw ParseError(
"expected 'template', semicolon, new line or '}'",
nextToken.pos);
}
if (!users->AddItem(new BUser(token.text, realName, home, shell,
groups))) {
throw std::bad_alloc();
}
}
} resolvableExpressionParser(*this, users);
_ParseList(resolvableExpressionParser, false);
}
void
BPackageInfo::Parser::_Parse(BPackageInfo* packageInfo)
{
bool seen[B_PACKAGE_INFO_ENUM_COUNT];
for (int i = 0; i < B_PACKAGE_INFO_ENUM_COUNT; ++i)
seen[i] = false;
const char* const* names = BPackageInfo::kElementNames;
while (Token t = _NextToken()) {
if (t.type == TOKEN_ITEM_SEPARATOR)
continue;
if (t.type != TOKEN_STRING)
throw ParseError("expected string (a variable name)", t.pos);
BPackageInfoAttributeID attribute = B_PACKAGE_INFO_ENUM_COUNT;
for (int i = 0; i < B_PACKAGE_INFO_ENUM_COUNT; i++) {
if (names[i] != NULL && t.text.ICompare(names[i]) == 0) {
attribute = (BPackageInfoAttributeID)i;
break;
}
}
if (attribute == B_PACKAGE_INFO_ENUM_COUNT) {
BString error = BString("unknown attribute \"") << t.text << '"';
throw ParseError(error, t.pos);
}
if (seen[attribute]) {
BString error = BString(names[attribute]) << " already seen!";
throw ParseError(error, t.pos);
}
switch (attribute) {
case B_PACKAGE_INFO_NAME:
{
BString name;
const char* namePos;
_ParseStringValue(&name, &namePos);
int32 errorPos;
if (!_IsValidResolvableName(name, &errorPos)) {
throw ParseError("invalid character in package name",
namePos + errorPos);
}
packageInfo->SetName(name);
break;
}
case B_PACKAGE_INFO_SUMMARY:
{
BString summary;
_ParseStringValue(&summary);
if (summary.FindFirst('\n') >= 0)
throw ParseError("the summary contains linebreaks", t.pos);
packageInfo->SetSummary(summary);
break;
}
case B_PACKAGE_INFO_DESCRIPTION:
_ParseStringValue(&packageInfo->fDescription);
break;
case B_PACKAGE_INFO_VENDOR:
_ParseStringValue(&packageInfo->fVendor);
break;
case B_PACKAGE_INFO_PACKAGER:
_ParseStringValue(&packageInfo->fPackager);
break;
case B_PACKAGE_INFO_BASE_PACKAGE:
_ParseStringValue(&packageInfo->fBasePackage);
break;
case B_PACKAGE_INFO_ARCHITECTURE:
_ParseArchitectureValue(&packageInfo->fArchitecture);
break;
case B_PACKAGE_INFO_VERSION:
_ParseVersionValue(&packageInfo->fVersion, false);
break;
case B_PACKAGE_INFO_COPYRIGHTS:
_ParseStringList(&packageInfo->fCopyrightList);
break;
case B_PACKAGE_INFO_LICENSES:
_ParseStringList(&packageInfo->fLicenseList);
break;
case B_PACKAGE_INFO_URLS:
{
UrlStringValidator stringValidator;
_ParseStringList(&packageInfo->fURLList,
false, false, &stringValidator);
}
break;
case B_PACKAGE_INFO_SOURCE_URLS:
{
UrlStringValidator stringValidator;
_ParseStringList(&packageInfo->fSourceURLList,
false, false, &stringValidator);
}
break;
case B_PACKAGE_INFO_GLOBAL_WRITABLE_FILES:
_ParseGlobalWritableFileInfos(
&packageInfo->fGlobalWritableFileInfos);
break;
case B_PACKAGE_INFO_USER_SETTINGS_FILES:
_ParseUserSettingsFileInfos(
&packageInfo->fUserSettingsFileInfos);
break;
case B_PACKAGE_INFO_USERS:
_ParseUsers(&packageInfo->fUsers);
break;
case B_PACKAGE_INFO_GROUPS:
_ParseStringList(&packageInfo->fGroups);
break;
case B_PACKAGE_INFO_POST_INSTALL_SCRIPTS:
_ParseStringList(&packageInfo->fPostInstallScripts);
break;
case B_PACKAGE_INFO_PRE_UNINSTALL_SCRIPTS:
_ParseStringList(&packageInfo->fPreUninstallScripts);
break;
case B_PACKAGE_INFO_PROVIDES:
_ParseResolvableList(&packageInfo->fProvidesList);
break;
case B_PACKAGE_INFO_REQUIRES:
packageInfo->fBasePackage.Truncate(0);
_ParseResolvableExprList(&packageInfo->fRequiresList,
&packageInfo->fBasePackage);
break;
case B_PACKAGE_INFO_SUPPLEMENTS:
_ParseResolvableExprList(&packageInfo->fSupplementsList);
break;
case B_PACKAGE_INFO_CONFLICTS:
_ParseResolvableExprList(&packageInfo->fConflictsList);
break;
case B_PACKAGE_INFO_FRESHENS:
_ParseResolvableExprList(&packageInfo->fFreshensList);
break;
case B_PACKAGE_INFO_REPLACES:
_ParseStringList(&packageInfo->fReplacesList, true);
break;
case B_PACKAGE_INFO_FLAGS:
packageInfo->SetFlags(_ParseFlags());
break;
default:
break;
}
seen[attribute] = true;
}
for (int i = 0; i <= B_PACKAGE_INFO_PROVIDES; ++i) {
if (!seen[i]) {
BString error = BString(names[i]) << " is not being set anywhere!";
throw ParseError(error, fPos);
}
}
}
inline bool
BPackageInfo::Parser::_IsAlphaNumUnderscore(const BString& string,
const char* additionalChars, int32* _errorPos)
{
return _IsAlphaNumUnderscore(string.String(),
string.String() + string.Length(), additionalChars, _errorPos);
}
inline bool
BPackageInfo::Parser::_IsAlphaNumUnderscore(const char* string,
const char* additionalChars, int32* _errorPos)
{
return _IsAlphaNumUnderscore(string, string + strlen(string),
additionalChars, _errorPos);
}
bool
BPackageInfo::Parser::_IsAlphaNumUnderscore(const char* start, const char* end,
const char* additionalChars, int32* _errorPos)
{
for (const char* c = start; c < end; c++) {
if (!isalnum(*c) && *c != '_' && strchr(additionalChars, *c) == NULL) {
if (_errorPos != NULL)
*_errorPos = c - start;
return false;
}
}
return true;
}
bool
BPackageInfo::Parser::_IsValidResolvableName(const char* string,
int32* _errorPos)
{
for (const char* c = string; *c != '\0'; c++) {
switch (*c) {
case '-':
case '/':
case '<':
case '>':
case '=':
case '!':
break;
default:
if (!isspace(*c))
continue;
break;
}
if (_errorPos != NULL)
*_errorPos = c - string;
return false;
}
return true;
}
void
BPackageInfo::Parser::UrlStringValidator::Validate(const BString& urlString,
const char* pos)
{
BUrl url(urlString, true);
if (!url.IsValid())
throw ParseError("invalid url", pos);
}
}
