/**
* @brief Token::tokens
* @return
*/
Tokens Token::tokens() const
{
Q_ASSERT(isMulti());
return m_Data.m_Tokens;
}
void AstSenTree::dump(ostream& str) {
this->AstNode::dump(str);
if (isMulti()) str<<" [MULTI]";
}
/**
* @brief ComponentsMaker::makeMethod
* @param tokens
* @return
*/
OptionalEntity ComponentsMaker::makeMethod(const Tokens &tokens)
{
Q_ASSERT(!tokens.isEmpty() &&
tokens[int(MethodsGroupsNames::ReturnType)]->isMulti() &&
tokens[int(MethodsGroupsNames::Name)]->isSingle());
Q_ASSERT(checkCommonState());
entity::SharedMethod newMethod = std::make_shared<entity::ClassMethod>();
// Add Lhs
auto lhsToken = tokens[int(MethodsGroupsNames::LhsKeywords)];
Q_ASSERT(!lhsToken->isEmpty() && lhsToken->isSingle());
for (auto &&w : lhsToken->token().split(QChar::Space, QString::SkipEmptyParts)) {
entity::LhsIdentificator id = utility::methodLhsIdFromString(w);
Q_ASSERT(id != entity::LhsIdentificator::None);
newMethod->addLhsIdentificator(id);
}
// Add return type
auto returnTypeToken = tokens[int(MethodsGroupsNames::ReturnType)];
Q_ASSERT(returnTypeToken->isMulti() && !returnTypeToken->isEmpty());
auto returnType = makeType(returnTypeToken->tokens());
if (!returnType.errorMessage.isEmpty())
return {returnType.errorMessage, nullptr};
newMethod->setReturnTypeId(returnType.resultEntity->id());
// Add name
newMethod->setName(tokens[int(MethodsGroupsNames::Name)]->token());
// Add arguments
auto argumentsToken = tokens[int(MethodsGroupsNames::Arguments)];
Q_ASSERT(argumentsToken->isEmpty() || argumentsToken->isMulti());
if (argumentsToken->isMulti()) {
auto argumentsTokens = argumentsToken->tokens();
for (auto &&argumentToken : argumentsTokens) {
Q_ASSERT(argumentToken->isMulti());
auto argSubTokens = argumentToken->tokens();
Q_ASSERT(argSubTokens.size() == int(Argument::GroupsCount));
Q_ASSERT(argSubTokens[int(Argument::Name)]->isSingle());
auto name = argSubTokens[int(Argument::Name)]->token();
Q_ASSERT(argSubTokens[int(Argument::Type)]->isMulti());
auto type = makeType(argSubTokens[int(Argument::Type)]->tokens());
if (!type.errorMessage.isEmpty())
return {tr("Wrong type of argument: %1. Error: %2.").arg(
QString::number(argumentsTokens.indexOf(argumentToken)),
type.errorMessage
), nullptr};
Q_ASSERT(type.resultEntity);
newMethod->addParameter(name, type.resultEntity->id());
}
}
// Const
auto constArgument = tokens[int(MethodsGroupsNames::Const)];
Q_ASSERT(!constArgument->isEmpty() && constArgument->isSingle());
const QString &token = constArgument->token();
if (!token.isEmpty()) {
if (token == "const")
newMethod->setConstStatus(true);
else
return {tr("Wrong const status token: %1.").arg(constArgument->token()), nullptr};
}
// Rhs
auto rhsArgument = tokens[int(MethodsGroupsNames::RhsKeywords)];
Q_ASSERT(!rhsArgument->isEmpty() && rhsArgument->isSingle());
const QString &rhsToken = rhsArgument->token();
if (!rhsToken.isEmpty()) {
entity::RhsIdentificator rhsId = utility::methodRhsIdFromString(rhsToken);
if (rhsId != entity::RhsIdentificator::None)
newMethod->setRhsIdentificator(rhsId);
else
return {tr("Wrong rhs keyword: %1").arg(rhsToken), nullptr};
}
return {"", newMethod};
}