ValueType validateGlobalIndex(const Module& module,Uptr globalIndex,bool mustBeMutable,bool mustBeImmutable,bool mustBeImport,const char* context)
{
VALIDATE_INDEX(globalIndex,module.globals.size());
const GlobalType& globalType = module.globals.getType(globalIndex);
if(mustBeMutable && !globalType.isMutable) { throw ValidationException("attempting to mutate immutable global"); }
else if(mustBeImport && globalIndex >= module.globals.imports.size()) { throw ValidationException("global variable initializer expression may only access imported globals"); }
else if(mustBeImmutable && globalType.isMutable) { throw ValidationException("global variable initializer expression may only access immutable globals"); }
return globalType.valueType;
}
void AuthRepositoryServer::validateAddUserParams ( authrepo::CommitNode& myHead, const std::string& licenseStaticId, const std::string& login, const std::string &password, const std::string& fullName, const std::string& email, const std::string& phone, bool enabled )
{
//validate params
if ( !myHead.getIndex()->getIndex ( m_dbStructure.getByName ( "license" ) )->findStaticId ( licenseStaticId ) )
throw ValidationException ( "unknown license" );
if ( myHead.getLoginIndex()->find ( login ) )
throw ValidationException ( "user exists" );
if ( login.length() < 6 )
throw ValidationException ( "login is too short, at least 6 letters required" );
if ( password.length() < 5 )
throw ValidationException ( "password is too short, at least 5 letters required" );
}
void AuthRepositoryServer::validateTrialParams ( authrepo::CommitNode& myHead, const RegistrationParams& params )
{
//validate params
if ( myHead.getLoginIndex()->find ( params.get_login() ) )
throw ValidationException ( "user exists" );
if ( params.get_login().length() < 6 )
throw ValidationException ( "login is too short, at least 6 letters required" );
if ( params.get_companyName().empty() )
throw ValidationException ( "Non-empty company name required" );
if ( params.get_password().length() < 5 )
throw ValidationException ( "password is too short, at least 5 letters required" );
}
void validateInitializer(const InitializerExpression& expression,ValueType expectedType,const char* context)
{
switch(expression.type)
{
case InitializerExpression::Type::i32_const:
validateType(expectedType,ValueType::i32,context);
break;
case InitializerExpression::Type::i64_const:
validateType(expectedType,ValueType::i64,context);
break;
case InitializerExpression::Type::f32_const:
validateType(expectedType,ValueType::f32,context);
break;
case InitializerExpression::Type::f64_const:
validateType(expectedType,ValueType::f64,context);
break;
case InitializerExpression::Type::get_global:
{
const ValueType globalValueType = validateGlobalIndex(expression.globalIndex,false,true,true,"initializer expression global index");
validateType(expectedType,globalValueType,context);
break;
}
default:
throw ValidationException("invalid initializer expression");
};
}
void validateBranchDepth(uintp depth) const
{
VALIDATE_INDEX(depth,controlStack.size());
if(depth >= controlStack.size()) {
throw ValidationException("invalid branch depth");
}
}
void validateImportKind(ObjectType importType,ObjectKind expectedKind)
{
if(importType.kind != expectedKind)
{
throw ValidationException("incorrect kind");
}
}
ValueType validateGlobalIndex(uintp globalIndex,bool mustBeMutable,bool mustBeImmutable,bool mustBeImport,const char* context)
{
assert(numImportedGlobals != UINTPTR_MAX);
VALIDATE_INDEX(globalIndex,globals.size());
const GlobalType& globalType = globals[globalIndex];
if(mustBeMutable && !globalType.isMutable) {
throw ValidationException("attempting to mutate immutable global");
}
else if(mustBeImport && globalIndex >= numImportedGlobals) {
throw ValidationException("global variable initializer expression may only access imported globals");
}
else if(mustBeImmutable && globalType.isMutable) {
throw ValidationException("global variable initializer expression may only access immutable globals");
}
return globalType.valueType;
}
void validateStackAccess(size_t num)
{
if(controlStack.back().isReachable)
{
const uintp stackBase = controlStack.back().outerStackSize;
if(stack.size() < stackBase + num) {
throw ValidationException("invalid stack access");
}
}
}
QDomElement& Race::toXml(QDomDocument& doc, QDomElement& parent) const
throw(ValidationException)
{
if(m_game == NULL)
throw ValidationException("Race", "game", "is null reference");
if(m_id.isEmpty())
throw ValidationException("Race", "id", "is null");
if(m_name.isEmpty())
throw ValidationException("Race", "name", "is null");
QDomProcessingInstruction header = doc.createProcessingInstruction("xml", "version=\"1.0\"");
doc.appendChild(header);
QDomElement root = doc.createElement("race");
QDomElement ruleSetNode = doc.createElement("rule_set");
RuleSet::toXml(doc, ruleSetNode);
QDomElement wargearsNode = doc.createElement("wargears");
WargearList::toXml(doc, wargearsNode);
QDomElement unitsNode = doc.createElement("units");
UnitList::toXml(doc, unitsNode);
appendElement(doc, root, "id", m_id);
appendElement(doc, root, "name", m_name);
QDomElement gameNode = doc.createElement("game");
UnresolvedReference game(m_game->id());
game.toXml(doc, gameNode);
root.appendChild(gameNode);
root.appendChild(ruleSetNode);
root.appendChild(wargearsNode);
root.appendChild(unitsNode);
doc.appendChild(root);
return parent;
}
void validateType(Type expectedType,Type type,const char* context)
{
if(expectedType != type)
{
throw ValidationException(
std::string("type mismatch: expected ") + asString(expectedType)
+ " but got " + asString(type)
+ " in " + context
);
}
}
void validateOperandType(ValueType expectedType,ValueType actualType,const char* context)
{
// Handle polymorphic values popped off the operand stack after unconditional branches.
if(expectedType != actualType && expectedType != ValueType::any && actualType != ValueType::any)
{
throw ValidationException(
std::string("type mismatch: expected ") + asString(expectedType)
+ " but got " + asString(actualType)
+ " in " + context + " operand"
);
}
}
QDomElement& RuleSet::toXml(QDomDocument& doc, QDomElement& parent) const
throw(ValidationException)
{
if(m_book.isEmpty())
throw ValidationException("RuleSet", "book", "is null");
if(m_edition.isEmpty())
throw ValidationException("RuleSet", "edition", "is null");
if(m_version.isEmpty())
throw ValidationException("RuleSet", "version", "is null");
QDomElement ruleList = doc.createElement("rules");
RuleList::toXml(doc, ruleList);
appendElement(doc, parent, "book", m_book);
appendElement(doc, parent, "edition", m_edition);
appendElement(doc, parent, "version", m_version);
parent.appendChild(ruleList);
return parent;
}
std::vector<const std::type_info*> InsertJ1::getArgTypes(unsigned int inN, GP::Context& ioContext) const {
std::vector<const std::type_info*> lTypes;
switch(inN) {
case 0:
lTypes.push_back(ArgBond);
return lTypes;
case 1:
lTypes.push_back(ArgBond);
return lTypes;
case 2:
lTypes.push_back(ArgJct1);
return lTypes;
default:
throw ValidationException("InsertJ1 should have no more than 3 arguments");
}
}
ValueType popOperand()
{
if(stack.size() > controlStack.back().outerStackSize)
{
const ValueType result = stack.back();
stack.pop_back();
return result;
}
else if(controlStack.back().isReachable)
{
throw ValidationException("invalid stack access");
}
else
{
return ValueType::any;
}
}
void popControlStack(bool isElse = false)
{
VALIDATE_UNLESS("stack was not empty at end of control structure: ",stack.size() > controlStack.back().outerStackSize);
if(isElse && controlStack.back().type == ControlContext::Type::ifThen)
{
controlStack.back().type = ControlContext::Type::ifElse;
controlStack.back().isReachable = true;
}
else
{
VALIDATE_UNLESS("else only allowed in if context: ",isElse);
const ResultType resultType = controlStack.back().resultType;
if(controlStack.back().type == ControlContext::Type::ifThen && resultType != ResultType::none)
{
throw ValidationException("else-less if may not yield a result");
}
controlStack.pop_back();
if(controlStack.size()) { pushOperand(resultType); }
}
}
void AuthRepositoryServer::updateUser (
authrepo::CommitNode& myHead,
const std::string& licenseStaticId, const std::string& login, const std::string &password,
const std::string& fullName, const std::string& email, const std::string& phone,
bool enabled, const std::string& roleStaticId, const std::vector<std::string>& groupStaticIdList,
const std::string &userStaticId
)
{
authrepo::DataNode *user_license = myHead.getIndex()->getIndex ( m_dbStructure.getByName ( "license" ) )->findStaticId ( licenseStaticId );
if ( !user_license ) throw ValidationException ( "unknown license" );
authrepo::DataNode *login_user = myHead.getLoginIndex()->find ( login );
authrepo::DataNode *user = myHead.getIndex()->getIndex ( m_dbStructure.getByName ( "user" ) )->findStaticId ( userStaticId );
if ( !user ) throw ValidationException ( "unknown user" );
if (login_user && login_user != user)
throw ValidationException ( "login exists" );
authrepo::PDataNode temp = user->getParent()->detachChild(user);
user_license->attachChild(temp);
{
user->setField ( "login", login );
user->setField ( "welcome_name", fullName );
user->setField ( "email", email );
user->setField ( "phone", phone );
user->setField ( "enabled", enabled ? "true" : "false" );
if(!roleStaticId.empty()) {
user->setField ( "srid", roleStaticId );
}
}
//NOTE: merge accessible group list
const authrepo::DBEntity *p_grouplinkEntity = m_dbStructure.getByName( "grouplink" );
//NOTE: detach all grouplinks from user, collect detached in a map
std::map<std::string, authrepo::PDataNode> currentGroupLink;
for(
authrepo::TChildrenMap::const_iterator itChildren = user->getChildren().begin();
itChildren != user->getChildren().end();
++itChildren
) {
//NOTE: loog only at grouplink items
if(itChildren->second->getTypeEntity() == p_grouplinkEntity) {
//NOTE: look for group staticid, skip if not found
std::map<std::string, std::string>::const_iterator itField = itChildren->second->fields().find("sgid");
if(itField != itChildren->second->fields().end()) {
currentGroupLink[itField->second] = itChildren->second;
user->detachChild(itChildren->second);
}
}
}
//NOTE: pass througs the actual groups
for(
std::vector<std::string>::const_iterator groupIt = groupStaticIdList.begin();
groupIt != groupStaticIdList.end();
++groupIt
) {
std::map<std::string, authrepo::PDataNode>::iterator it = currentGroupLink.find( *groupIt );
if(it == currentGroupLink.end()) {
//NOTE: create new grouplink
authrepo::DataNode *grouplink = user->createChild ( "grouplink", authrepo::util::generateId ( "" ) );
grouplink->setField("sgid", *groupIt);
myHead.checkSharePermission(grouplink);
} else {
//NOTE: attach existing grouplink
user->attachChild(it->second);
}
}
}
void ListValidator::validate(string listName) throw (ValidationException) {
if(listName == "") {
throw ValidationException("Invalid name!");
}
}
void validate(TableElementType type)
{
if(type != TableElementType::anyfunc) {
throw ValidationException("invalid table element type (" + std::to_string((uintp)type) + ")");
}
}
void error(ErrorImm imm) {
throw ValidationException("error opcode");
}
void AuthRepositoryServer::validateUpdateUserParams ( authrepo::CommitNode& myHead, const std::string& licenseStaticId, const std::string& login, const std::string &password, const std::string& fullName, const std::string& email, const std::string& phone, bool enabled, const std::string &userStaticId)
{
if ( !password.empty() && password.length() < 5 )
throw ValidationException ( "password is too short, at least 5 letters required" );
}
