argsparser.h

Go to the documentation of this file.

/***************************************************************************
 * Authors:     J.M.de la Rosa Trevin (jmdelarosa@cnb.csic.es)
 *
 *
 * Unidad de  Bioinformatica of Centro Nacional de Biotecnologia , CSIC
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your param) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
 * 02111-1307  USA
 *
 *  All comments concerning this program package may be sent to the
 *  e-mail address 'xmipp@cnb.csic.es'
 ***************************************************************************/

#ifndef CORE_ARGSPARSER_H_
#define CORE_ARGSPARSER_H_

#include <map>
#include <iostream>
#include "xmipp_strings.h"
#include "comment_list.h"

//TODO (MARIANA) Please give more documentation and in a good structure e.g. @name (see args.h as example)
/* MARIANA: I defined the name of this group. Please define it as you want. */

typedef enum {
    TOK_ID,     //identifier
    TOK_OPT,    // -ID or --ID
    TOK_INT,    //integer number
    TOK_FLOAT,  //float number
    TOK_STR,    //string value
    TOK_MINUS,  // - or --
    TOK_PLUS,   // +
    TOK_EQ,     // =
    TOK_COMM,   // Comment, from : until end of line
    TOK_LAN,    // <
    TOK_RAN,    // >
    TOK_LBRA,   // [
    TOK_RBRA,   // ]
    TOK_SEMI,   // semicolor ;
    TOK_COMMA,  // ,
    TOK_ETC,    // ...
    TOK_END,    // end of input
    TOK_WHERE,  // 'WHERE' keyword
    TOK_ALIAS,  // 'ALIAS' keyword
    TOK_OR,     // 'OR' keyword
    TOK_REQUIRES,// 'REQUIRES' keyword
    TOK_SECTION // section defined by == Section ==
} ArgTokenType;

class ProgramDef;

class ArgToken
{
public:
    ArgTokenType type; 
    String lexeme; 
    int line; 
    int start, end; 
    int visibility;
    bool starred;

    static const char * typeString(ArgTokenType type);
};

class ArgLexer
{
private:
    StringVector input;
    size_t line;
    size_t pos; 
    size_t offset; 
    ArgToken * pToken; 
    std::map<String, ArgTokenType> reservedWords;

    //Some utils functions
    void readSpaces();
    void readDigits();
    void readId();
    void setupToken(ArgTokenType type);
    void checkVisibility();
    void checkIndependent();
    void nextLine();

public:
    ArgLexer();
    ~ArgLexer();
    void addLine(const String &line);
    bool nextToken();
    ArgToken * currentToken() const;
    ArgTokenType lookahead() const;

};

class ASTNode
{
public:
    ASTNode(ArgLexer *lexer = NULL, ASTNode * parent = NULL);
    virtual ~ASTNode()
    {
    }
    ;

    ASTNode * parent;
    ArgLexer * pLexer;
    ArgToken token;
    String name;
    int visible;

    virtual bool parse() = 0; //abstract function
    virtual void check(std::stringstream & errors) = 0; //abstract function
    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 = "");
};

class ParamDef;

class ArgumentDef: public ASTNode
{
public:
    String argDefault;
    bool isList;
    bool isType;
    std::vector<ParamDef*> subParams;
    bool hasDefault;

    ArgumentDef(ArgLexer *lexer, ASTNode * parent);
    ~ArgumentDef();
    virtual bool parse();
    virtual void check(std::stringstream & errors)
    {
    }
    // to pass to this parameter and increase the index
    bool acceptArguments(std::stringstream &errors, size_t &argIndex, std::vector<const char *> &cmdArguments);
};

class ParamDef: public ASTNode
{
public:
    bool notOptional; //contradictory param not paramal :)
    bool orBefore;
    bool independent;
    std::vector<ArgumentDef*> arguments;
    std::vector<const char *> cmdArguments;
    std::vector<ParamDef*> *exclusiveGroup;
    int counter; 

    CommentList comments;
    StringVector aliases;
    StringVector requires;

    //Empty constructor
    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);
};

class SectionDef: public ASTNode
{
public:
    CommentList comments;
    std::vector<ParamDef*> params; 

    SectionDef(ArgLexer * lexer, ASTNode * parent);
    ~SectionDef();
    virtual bool parse();
    virtual void check(std::stringstream & errors)
    {
    }
    void addParamDef(ParamDef * param);
};

class ProgramDef: public ASTNode
{
private:
  std::vector<ParamDef*> *exclusiveGroup;
public:
    std::vector<SectionDef*> sections;
    CommentList usageComments; 
    CommentList examples; 
    std::map<String, ParamDef*> paramsMap; 
    StringVector pendingRequires; 
    String keywords;
    String seeAlso;
    bool singleOption;

    ProgramDef();
    ~ProgramDef();
    virtual bool parse();
    virtual void check(std::stringstream & errors);
    ParamDef * findParam(const String &param);
    ParamDef * findAndFillParam(const String &param);
    const char * getParam(const char * paramName, size_t paramNumber = 0);
    const char * getParam(const char * paramName, const char * subParam, size_t paramNumber = 0);
    void addParamName(const String & name, ParamDef *param);
    void addParamRequires(const String &name);
    void addParamExclusiveGroup(ParamDef * param);
    void clear();
    void read(int argc, const char ** argv, bool reportErrors = true);
    SectionDef * addSection(String sectionName, int visibility = 0);

};

#endif /* ARGSPARSER_H_ */