driver.hh

Go to the documentation of this file.

/*
 *  Copyright 2007 Martin von Gagern
 *
 *
 *  This file is part of mqn2mps.
 *
 *  mqn2mps 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 3 of the License, or
 *  (at your option) any later version.
 *
 *  mqn2mps 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, see <http://www.gnu.org/licenses/>.
 */


#ifndef DRIVER_HH
#define DRIVER_HH

#include <string>
#include <vector>
#include <map>
#include <iostream>

#include "rational.hh"
#include "parser.hh"
#include "lexer.hh"

/**
 * @file
 * Interface of class driver.
 */

/**
 * The driver class is the central component of the program.
 * It manages the command line arguments and current settings, and
 * uses ofther classes for input parsing, problem formulation and file
 * output.
 */
class driver {

public:
  driver();
  virtual ~driver();

  void usage(const char* cmd, std::ostream& out);
  void parse_opts(int argc, char** argv);
  void parse_file(const char *file);
  void parse_stdin();

  void set_names(const yy::location& location,
                 std::vector<std::string>* qns);
  void set_constraints(const yy::location& location,
                       std::vector<constraint>* css);
  field* checked_field(const yy::location& location,
                       std::string* name,
                       std::vector<rational>* rationals);
  void set_fields(const yy::location& location,
                  std::vector<field>* vcs);
  void result(const yy::location& location,
              std::string* name);

  int scan(yy::parser::semantic_type* yylval,
           yy::parser::location_type* yylloc);

  void parse(const std::string& file);

  /**
   * The file name of the file currently being processed.
   */
  std::string file;

  void error(const yy::location& location, const std::string& message);
  void error(const std::string& message);

  /**
   * Command line option @c --multiply-k.
   *
   * When this option is specified, all columns with a name starting
   * with @c n_ will be multiplied with the value of the column named
   * @c k.
   *
   * @see mipgen::multiply_k, usage
   */
  bool multiply_k;

  /**
   * Command line option @c --gamma.
   *
   * When this option is specified, a pair of inequalities is added to
   * ensure that no single fractional value is the only nonzero value
   * of a solution.
   *
   * @see mipgen::append_gamma, usage
   */
  bool gamma_constraint;

  /**
   * Command line option @c --max-order.
   *
   * This specifies the maximum number of vectors any solution may
   * have.
   *
   * @see mipgen::set_bounds, usage
   */
  int max_order;

  /**
   * Command line option @c --min-order.
   *
   * This specifies the minimum number of vectors any solution must
   * have.
   *
   * @see mipgen::set_bounds, usage
   */
  int min_order;

  /**
   * Command line option @c --format.
   *
   * This gives the name of the output format that should be used.
   * Each format is implemented by its own class, derived from
   * mipgen. Currently supported formats are:
   *  - @c mps implemented by mpsgen
   *  - @c opb implemented by opbgen
   *  - @c csv implemented by mipgen itself
   *
   * @see process, usage
   */
  std::string format;

  /**
   * Instance name, as specified in the input file.
   *
   * The input format may start by giving an arbitrary name for the
   * instance. If a name is given, it will be stored here, otherwise a
   * default will be used.
   */
  std::string name;

  /**
   * Row names.
   *
   * The names of the rows (i.e. quantum numbers) will be stored in
   * this vector in the order in which they are given in the input
   * file.
   */
  std::vector<std::string> names;

  /**
   * Row numbers.
   *
   * This table maps row names to the corresponding row numbers. It
   * can be used to look up a component by name.
   */
  std::map<std::string, int> indices;

  /**
   * Row constraints.
   *
   * These give the constraints that a row must fulfill, like a given
   * target value, and maybe the modulo arithmetic to be used. Rows
   * are identified using their name. The order of the components is
   * given by the order of the names attribute, which might be
   * different from the order of the constraints.
   */
  std::vector<constraint> constraints;

  /**
   * Columns.
   *
   * The columns are represented through field objects, which contain
   * a column name along with the values, in the order specified by
   * the names vector.
   */
  std::vector<field> fields;

private:

  /**
   * The lexer used to scan input files.
   */
  yy::lexer* theLexer;

  /**
   * Internal flag to enable lexer debug output.
   */
  bool trace_scanning;

  /**
   * Internal flag to enable parser debug output.
   */
  bool trace_parsing;

  /**
   * Counter of errors during input parsing.
   *
   * When the parser completes and there have been any errors along
   * the way, the file will not be processed.
   */
  int errorCount;

protected:
  void parse(const char *file, std::istream &in);
  virtual void process(const char* file);
};

/**
 * Wrapper around the lexer.
 * By using this method, the driver doesn't have to know anything at
 * all about the actual lexer implementation.
 *
 * @param[out] yylval the value of the token.
 * @param[out] yylloc the location of the token.
 * @return the type code of the token.
 */
inline int driver::scan(yy::parser::semantic_type* yylval,
                        yy::parser::location_type* yylloc) {
  return theLexer->yylex(yylval, yylloc);
}

#endif // ifndef DRIVER_HH

---