driver.cc

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/>.
 */


#include <fstream>
#include <cstdlib>
#include <getopt.h>
#include <utility>
#include <sstream>
#include <limits>

#include "driver.hh"
#include "bounds.hh"
#include "mipgen.hh"
#include "mpsgen.hh"
#include "opbgen.hh"

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

/**
 * Constructor.
 * This constructor sets default values for command line arguments and
 * internal flags.
 */
driver::driver()
  : multiply_k(false),
    gamma_constraint(false),
    max_order(10),
    min_order(1),
    format("mps"),
    trace_scanning(false),
    trace_parsing(false)
{
}

/**
 * Destructor.
 * Only implemented so that overriding classes may get destructed
 * cleanly. This base class destructor does nothing so far.
 */
driver::~driver() {
}

/**
 * Print usage information.
 *
 * Whenever a new option is introduced, it should be added here, along
 * with a description. The usage information can be displayed by
 * passing the argumen @c --help on the command line.
 *
 * @param cmd the name of the executable as given on the command
 *            line.
 * @param out the output stream to which the information will be
 *            printed.
 * @see parse_opts
 */
void driver::usage(const char* cmd, std::ostream& out) {
  out << "Usage: " << cmd << " [opts] [files...]" << std::endl
      << "Options:" << std::endl
      << "  -f  --format=STR     choose output format STR" << std::endl
      << "  -g  --gamma          Disallow single fractional gamma" << std::endl
      << "  -h  --help           display this help you see now" << std::endl
      << "  -k  --multiply-k     multiply all n_* by k" << std::endl
      << "  -l  --min-order=INT  specify left hand side of limiting row" << std::endl
      << "  -m  --max-order=INT  specify right hand side of limiting row" << std::endl
      << "Formats:" << std::endl
      << "  mps  common format for linear and mixed integer optimization" << std::endl
      << "  opb  format for the opbdp pseudo boolean optimizer" << std::endl
      << "  csv  tabbed text for spreadsheet applications" << std::endl
    ;
}

/**
 * Parse and execute command line options.
 *
 * The list of command line options that the program recognizes is
 * given here. It should be kept in sync with what usage prints. Most
 * arguments can be given using either a short or a long name.
 *
 * @param argc the number of command line arguments.
 * @param argv an array of command line arguments.
 */
void driver::parse_opts(int argc, char** argv) {
  int trace_scanning = 0, trace_parsing = 0;
  struct option opts[] = {
    { "format"        , required_argument, NULL,            'f' },
    { "gamma"         , no_argument,       NULL,            'g' },
    { "help"          , no_argument,       NULL,            'h' },
    { "multiply-k"    , no_argument,       NULL,            'k' },
    { "min-order"     , required_argument, NULL,            'l' },
    { "max-order"     , required_argument, NULL,            'm' },
    { "trace-scanning", no_argument,       &trace_scanning,  1  },
    { "trace-parsing" , no_argument,       &trace_parsing ,  1  },
    { 0, 0, 0, 0 }
  };

  for (;;) {
    int index = 0;
    int chr = getopt_long(argc, argv, "f:ghkl:m:", opts, &index);
    if (chr == -1) break;
    switch (chr) {
    case 0:
      // long option without corresponding short one
      // switch (index) { }
      break;
    case 'f':
      format = optarg;
      if (format != "mps" && format != "opb" && format != "csv") {
        std::cerr << "Unsupported format: " << format << std::endl;
        exit(EXIT_FAILURE);
      }
      break;
    case 'g':
      gamma_constraint = true;
      break;
    case 'h':
      usage(argv[0], std::cout);
      exit(EXIT_SUCCESS);
      break;
    case 'k':
      multiply_k = true;
      break;
    case 'l':
      min_order = atoi(optarg);
      break;
    case 'm':
      max_order = atoi(optarg);
      break;
    default:
      usage(argv[0], std::cerr);
      exit(EXIT_FAILURE);
    }
  }

  this->trace_scanning = trace_scanning;
  this->trace_parsing = trace_parsing;

  if (optind < argc) {
    while (optind < argc)
      parse_file(argv[optind++]);
  }
  else {
    parse_stdin();
  }
}

/**
 * Handle a single input file.
 * This includes parsing the file and processing its content.
 *
 * @param infile the file to be read.
 * @see parse
 * @see process
 */
void driver::parse_file(const char *infile) {
  std::ifstream in(infile);
  parse(infile, in);
  in.close();
  if (errorCount) return;
  std::string outfile(infile);
  if (outfile.find(".mqn", outfile.size() - 4) == outfile.size() - 4)
    outfile.erase(outfile.size() - 3);
  outfile.append(format);
  process(outfile.c_str());
}

/**
 * Handle input from the standard input stream.
 * This includes parsing the stream and processing its content.
 *
 * @see parse
 * @see process
 */
void driver::parse_stdin() {
  parse("<stdin>", std::cin);
  if (errorCount) return;
  process(0);
}

/**
 * Parse an input stream.
 * Combines the common parsing process of parse_file and parse_stdin.
 *
 * @param file the file name, as it should appear in parser error
 *             messages.
 * @param in the input stream from which the scanner will read its
 *           tokens.
 */
void driver::parse(const char* file, std::istream& in) {
  errorCount = 0;
  this->file = file;

  yy::lexer lexer(*this, &in, &std::cerr);
  this->theLexer = &lexer;
  lexer.set_debug(trace_scanning);

  yy::parser parser(*this);
  parser.set_debug_level(trace_parsing);
  if (parser.parse()) ++errorCount;

  this->theLexer = 0;
  this->file = "<closed>";
}

/**
 * Print a localized parser error message.
 * The error counter is incremented as well, so that the file won't be
 * processed afterwards.
 *
 * @param location the position in the input file where the error
 *                 occurred.
 * @param message a textual description of the error.
 */
void driver::error(const yy::location& location, const std::string& message) {
  std::cerr << location << ": " << message << std::endl;
  errorCount++;
}

/**
 * Print an unlocalized parser error message.
 * The error counter is incremented as well, so that the file won't be
 * processed afterwards.
 *
 * @param message a textual description of the error.
 */
void driver::error(const std::string& message) {
  std::cerr << message << std::endl;
  errorCount++;
}

/**
 * Accept the vector of quantum number names from the parser.
 * The names will be checked to ensure that all special names required
 * by certain command line options are indeed present, and that no
 * duplicate names occur. Names beginning with an underscore are
 * reserved for generated columns and may not be used in input.
 * The indices map will be updated here as well.
 *
 * @param location the position in the source file where the list of
 *                 names started, to be used in error messages.
 * @param qns a pointer to the new list of names, this function will
 *            take care of releasing the memory for this object.
 */
void driver::set_names(const yy::location& location,
                       std::vector<std::string>* qns) {
  std::swap(names, *qns);
  delete qns;
  indices.clear();
  for (int i = 0; i < (int)names.size(); ++i) {
    if (names[i].empty()) {
      error(location, "names must not be empty");
    }
    if (names[i][0] == '_') {
      error(location, "names beginning with _ are reserved");
    }
    if (!indices.insert(make_pair(names[i], i)).second) {
      error(location, "duplicate name: " + names[i]);
    }
  }
  if (multiply_k && indices.find("k") == indices.end()) {
    error(location, "no element named k to multiply n_i");
  }
  if (gamma_constraint && indices.find("gamma") == indices.end()) {
    error(location, "no element named gamma for special gamma constraint");
  }
}

/**
 * Accept the vector of constraint (row) specifications from the
 * parser.
 * The method will check to ensure that each name given in one of
 * these constraints is present in the list of quantum number names as
 * well.
 *
 * @param location the position in the source file where the list of
 *                 constraints started, to be used in error messages.
 * @param css a pointer to the new list of constraints, this function
 *            will take care of releasing the memory for this object.
 */
void driver::set_constraints(const yy::location& location,
                             std::vector<constraint>* css) {
  std::swap(constraints, *css);
  delete css;
  typedef std::vector<constraint>::iterator iter;
  for (iter i = constraints.begin(), e = constraints.end(); i != e; ++i) {
    if (indices.find(i->name) == indices.end()) {
      error(location, "no such name: " + i->name);
    }
  }
}

/**
 * Accept the vector of field (column) specifications from the
 * parser.
 * There is no error checking, as each field is checked individually
 * using the checked_field() method.
 *
 * @param location the position in the source file where the list of
 *                 constraints started, to be used in error messages.
 * @param vcs a pointer to the new list of vectors, this function
 *            will take care of releasing the memory for this object.
 */
void driver::set_fields(const yy::location&,
                        std::vector<field>* vcs) {
  std::swap(fields, *vcs);
  delete vcs;
}

/**
 * Check a field (column) specification while parsing.
 * The method ensures that there are no invalid names, and that the
 * number of values matches the number of quantum number names passed
 * to set_names() before. If anything is wrong, an error is printed.
 *
 * @param location the position in the source file where the field
 *                 specification started, to be used in error
 *                 messages.
 * @param name the name of the new field, this function will take care
 *             of releasing the memory for this object.
 * @param rationals the component values of the field, this function
 *                  will take care of releasing the memory for this
 *                  object.
 * @return a pointer to a new field constructed from the input values,
 *         or 0 in case of a serious error.
 */
field* driver::checked_field(const yy::location& location,
                             std::string* name,
                             std::vector<rational>* rationals) {
  if (name->empty()) {
    error(location, "names must not be empty");
  }
  if ((*name)[0] == '_') {
    error(location, "names beginning with _ are reserved");
  }
  if (rationals->size() == names.size()) {
    return new field(name, rationals);
  }
  else {
    std::ostringstream ss;
    if (rationals->size() < names.size())
      ss << "too few";
    else
      ss << "too many";
    ss << " entries in field " << *name
       << ": expected " << names.size() << " but found " << rationals->size();
    error(location, ss.str());
    delete name;
    delete rationals;
    return 0;
  }
}

/**
 * Accept instance name from parser.
 * This method is invoked by the parser just as a complete input
 * stream has been parsed.
 *
 * @param location the location where the instance started, not used.
 * @param name the name of the problem instance, this function will
 *             take care of releasing the memory for this object.
 */
void driver::result(const yy::location&,
                    std::string* name) {
  std::swap(this->name, *name);
  delete name;
}

/**
 * Process one parsed file.
 *
 * The file has already been parsed and will be processed to the
 * matching output format.
 *
 * @param file the input file that should be processed
 * @see format
 */
void driver::process(const char* file) {
  mipgen *gen;
  if (format == "opb") gen = new opbgen(*this);
  else if (format == "mps") gen = new mpsgen(*this);
  else gen = new mipgen(*this);
  gen->formulate();
  gen->write(file);
  delete gen;
}

---