ParamDef Class Reference

#include <argsparser.h>

Inheritance diagram for ParamDef:

Collaboration diagram for ParamDef:

Public Member Functions
	ParamDef (ArgLexer *lexer, ASTNode *parent)
	~ParamDef ()
bool	parseParamList (ArgTokenType startToken, ProgramDef *prog, StringVector &paramList, bool addName)
bool	parseArgumentList ()
virtual bool	parse ()
bool	checkRequires (std::stringstream &errors, ProgramDef *prog)
virtual void	check (std::stringstream &errors)
bool	containsArgument (const String &argName)
ArgumentDef *	findArgument (const String &argName)
bool	containsAlias (const String &alias)
Public Member Functions inherited from ASTNode
	ASTNode (ArgLexer *lexer=NULL, ASTNode *parent=NULL)
virtual	~ASTNode ()
virtual bool	consume (ArgTokenType type)
ArgTokenType	lookahead () const
bool	lookahead (ArgTokenType type) const
ArgToken *	currentToken () const
void	nextToken ()
bool	parseCommentList (CommentList &comments)
void	error (String msg)
void	unexpectedToken (String msg="")

Public Attributes
bool	notOptional
bool	orBefore
bool	independent
std::vector< ArgumentDef * >	arguments
std::vector< const char * >	cmdArguments
std::vector< ParamDef * > *	exclusiveGroup
int	counter
	for count the number of times it appears in command line More...
CommentList	comments
StringVector	aliases
StringVector	requires
Public Attributes inherited from ASTNode
ASTNode *	parent
ArgLexer *	pLexer
ArgToken	token
String	name
int	visible

Detailed Description

Class representing the definition of an param An param definition is in the form:

Definition at line 192 of file argsparser.h.

Constructor & Destructor Documentation

ParamDef()

ParamDef::ParamDef	(	ArgLexer *	lexer,
		ASTNode *	parent
	)

Definition at line 522 of file argsparser.cpp.

                                                    :
        ASTNode(lexer, parent)
{
    exclusiveGroup = NULL;
    orBefore = false;
}

~ParamDef()

ParamDef::~ParamDef

(

)

Definition at line 529 of file argsparser.cpp.

{
    for (size_t i = 0; i < arguments.size(); ++i)
        delete arguments[i];
    if (!orBefore)
        delete exclusiveGroup;
}

Member Function Documentation

check()

void ParamDef::check ( std::stringstream &  errors )

virtual

Implements ASTNode.

Definition at line 715 of file argsparser.cpp.

{
    String aaa = name;

    ProgramDef * prog = (ProgramDef*) parent->parent;
    if (counter > 1 )
    {
        errors << "Duplicated parameter: " << name << " (check alias)" << std::endl;
        return;
    }

    if (counter == 1)
    {
        //Check requires restrictions
        checkRequires(errors, prog);

        //Check the number of arguments
        if (arguments.empty()) //if not arguments
        {
            if (!cmdArguments.empty())
                errors << "Parameter " << name << " doesn't take any argument, "
                << cmdArguments.size() << " provided." << std::endl;
        }
        else
        {
            size_t argIndex = 0;

            for (size_t i = 0; i < arguments.size(); ++i)
                if (!arguments[i]->acceptArguments(errors, argIndex, cmdArguments))
                {
                    errors << " parameter: " << name << std::endl;
                    return;
                }

            if (argIndex < cmdArguments.size() && !arguments[arguments.size()-1]->isList)
                errors << "Too many arguments for parameter " << name << std::endl;
        }
    }
    else
    {
        //Fill default arguments
        for (size_t i = 0; i < arguments.size(); ++i)
            if (arguments[i]->hasDefault)
                cmdArguments.push_back(arguments[i]->argDefault.c_str());
    }
}

checkRequires()

bool ParamDef::checkRequires	(	std::stringstream &	errors,
		ProgramDef *	prog
	)

Definition at line 699 of file argsparser.cpp.

{
    ParamDef * param;
    bool correct = true;
    for (size_t i = 0; i < requires.size(); ++i)
    {
        param = prog->findParam(requires[i]);
        if (param->counter < 1)
        {
            errors << "Parameter " << name << " requires " << requires[i] << std::endl;
            correct = false;
        }
    }
    return correct;
}

containsAlias()

bool ParamDef::containsAlias

(

const String &

alias

)

Definition at line 550 of file argsparser.cpp.

{
    for (size_t i = 0; i < aliases.size(); ++i)
        if (alias == aliases[i])
            return true;
    return false;
}

containsArgument()

bool ParamDef::containsArgument

(

const String &

argName

)

Definition at line 537 of file argsparser.cpp.

{
    return findArgument(argName) == NULL;
}

findArgument()

ArgumentDef * ParamDef::findArgument

(

const String &

argName

)

Definition at line 542 of file argsparser.cpp.

{
    for (size_t i = 0; i < arguments.size(); ++i)
        if (argName == arguments[i]->name)
            return arguments[i];
    return NULL;
}

parse()

bool ParamDef::parse ( )

virtual

Implements ASTNode.

Definition at line 558 of file argsparser.cpp.

{
    ProgramDef * prog = (ProgramDef*) parent->parent;
    notOptional = true;
    orBefore = false;
    independent = false;
    counter = 0;

    //Param Definition(OD)
    //OD -> OH CL
    //Param Header(OH)
    //OH -> O | [O] | OR O
    //Param(O)
    //O -> param AL
    if (lookahead(TOK_LBRA))
    {
        consume(TOK_LBRA);
        notOptional = false;
    }
    else if (lookahead(TOK_OR))
    {
        consume(TOK_OR);
        orBefore = true;
    }
    prog->addParamExclusiveGroup(this);

    consume(TOK_OPT);
    name = token.lexeme;
    visible = token.visibility;
    independent = token.starred;

    prog->addParamName(name, this);

    //Parse argument list
    parseArgumentList();

    if (notOptional == false)
        consume(TOK_RBRA);

    //Parse comment list
    parseCommentList(comments);

    //WHERE section
    while (lookahead(TOK_WHERE))
    {
        consume(TOK_WHERE);
        while (lookahead(TOK_LAN))
        {
            consume(TOK_LAN);
            consume(TOK_ID);
            ArgumentDef * pArg = findArgument(token.lexeme);
            if (pArg == NULL)
            {
                std::cerr << "ERROR; on WHERE definition.\n Param '" << name
                << "' not contains argument '" << token.lexeme << "'"
                << std::endl;
                exit(1);
            }
            consume(TOK_RAN);

            while (lookahead(TOK_ID))
            {
                ParamDef * pOpt = new ParamDef(pLexer, this);
                pOpt->consume(TOK_ID);

                pOpt->name = pOpt->token.lexeme;
                pOpt->parseArgumentList();
                pOpt->parseCommentList(pOpt->comments);
                pOpt->parseParamList(TOK_REQUIRES, prog, pOpt->requires, false);
                pArg->subParams.push_back(pOpt);
            }

        }
    }

    //ALIAS section
    parseParamList(TOK_ALIAS, prog, aliases, true);

    //REQUIRES section
    parseParamList(TOK_REQUIRES, prog, requires, false);

    return true;
}

parseArgumentList()

bool ParamDef::parseArgumentList

(

)

Definition at line 642 of file argsparser.cpp.

{
    bool previousList = false; // to check only one list and at end of arguments
    bool previousDefault = false; // to check that default values only can be at end
    //Argument List (AL)
    //AL -> argument  AL | e
    while (lookahead(TOK_LAN))
    {
        ArgumentDef * arg = new ArgumentDef(pLexer, this);
        arg->parse();
        token = arg->token;

        if (previousList)
            error("A list <...> has found not at the end of argument list");

        if (previousDefault && !arg->hasDefault)
            error("A non default argument was found before a default one");

        previousList = arg->isList;
        previousDefault = arg->hasDefault;

        arguments.push_back(arg);
    }
    return true;
}

parseParamList()

bool ParamDef::parseParamList	(	ArgTokenType	startToken,
		ProgramDef *	prog,
		StringVector &	paramList,
		bool	addName
	)

Definition at line 668 of file argsparser.cpp.

{
    paramList.clear();
    if (lookahead(startToken))
    {
        consume(startToken);
        consume(TOK_OPT);
        paramList.push_back(token.lexeme);

        if (isAlias)
            prog->addParamName(token.lexeme, this);
        else
            prog->addParamRequires(token.lexeme);

        while (lookahead(TOK_COMMA))
        {
            consume(TOK_COMMA);
            consume(TOK_OPT);
            paramList.push_back(token.lexeme);
            if (isAlias)
                prog->addParamName(token.lexeme, this);
            else
                prog->addParamRequires(token.lexeme);
        }
        consume(TOK_SEMI);
    }

    return true;
}

Member Data Documentation

aliases

StringVector ParamDef::aliases

Definition at line 204 of file argsparser.h.

arguments

std::vector<ArgumentDef*> ParamDef::arguments

Definition at line 198 of file argsparser.h.

cmdArguments

std::vector<const char *> ParamDef::cmdArguments

Definition at line 199 of file argsparser.h.

comments

CommentList ParamDef::comments

Definition at line 203 of file argsparser.h.

counter

int ParamDef::counter

for count the number of times it appears in command line

Definition at line 201 of file argsparser.h.

exclusiveGroup

std::vector<ParamDef*>* ParamDef::exclusiveGroup

Definition at line 200 of file argsparser.h.

independent

bool ParamDef::independent

Definition at line 197 of file argsparser.h.

notOptional

bool ParamDef::notOptional

Definition at line 195 of file argsparser.h.

orBefore

bool ParamDef::orBefore

Definition at line 196 of file argsparser.h.

requires

StringVector ParamDef::requires

Definition at line 205 of file argsparser.h.

---

The documentation for this class was generated from the following files:

• xmippCore/core/argsparser.h
• xmippCore/core/argsparser.cpp