parser.h

Go to the documentation of this file.

// 
// Copyright (c) Benjamin Kaufmann
// 
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/ 
// 
// Clasp 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 option) any later version.
// 
// Clasp 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 Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef CLASP_PARSER_H_INCLUDED
#define CLASP_PARSER_H_INCLUDED

#ifdef _MSC_VER
#pragma once
#endif

#include <istream>
#include <stdexcept>
#include <clasp/literal.h>
#include <clasp/claspfwd.h>
namespace Clasp {

struct ParseError : public ClaspError {
        ParseError(unsigned line, const char* msg);
        unsigned line;
};

struct Input_t {
        static InputFormat detectFormat(std::istream& prg);


        static bool parseLparse(std::istream& prg, Asp::LogicProgram& api);


        static bool parseDimacs(std::istream& prg, SatBuilder& api);
        

        static bool parseOPB(std::istream& prg, PBBuilder& api);
};
// PARSING BASE
class StreamParser {
public:
        StreamParser();
        virtual ~StreamParser();
        bool parse(StreamSource& prg);
protected:
        StreamSource* input() const { return source_;  }
        bool          check(bool cond, const char* condError) const;
        virtual bool  doParse() = 0;
        bool          skipComments(const char* commentStr);
private:
        StreamSource* source_;
};
// LPARSE PARSING
class LparseParser : public StreamParser {
public:
        explicit LparseParser(Asp::LogicProgram& prg);
        void setProgram(Asp::LogicProgram& prg);
protected:
        virtual bool doParse();
        virtual bool parseRuleExtension(int ruleType) = 0;
        virtual bool endParse();
        Var  parseAtom();
        bool parseBody(uint32 lits, uint32 neg, bool weights);
        Asp::LogicProgram* builder() const { return builder_; }
        Asp::Rule*         active()  const { return active_;  }
        bool               addRule(const Asp::Rule& r) const;
private:
        bool parseRules();
        bool parseRule(int ruleType);
        bool parseSymbolTable();
        bool parseComputeStatement();
        bool parseModels();
        bool knownRuleType(int rt) { return rt > 0 && rt <= 8 && rt != 4 && rt != 7; }
        Asp::LogicProgram* builder_;
        Asp::Rule*         active_;
};
class DefaultLparseParser : public LparseParser {
public:
        DefaultLparseParser(Asp::LogicProgram& prg);
protected:
        // Throws ParseError
        bool parseRuleExtension(int ruleType);
};
// DIMACS PARSING
class DimacsParser : public StreamParser {
public:
        explicit DimacsParser(SatBuilder& prg);
        void     setProgram(SatBuilder& prg);
protected:
        bool doParse();
private:
        void parseHeader();
        void parseClauses();
        SatBuilder* builder_;
        int         numVar_;
        bool        wcnf_;
};
// OPB PARSING
class OPBParser : public StreamParser {
public:
        explicit OPBParser(PBBuilder& prg);
        void setProgram(PBBuilder& prg);
protected:
        bool doParse();
private:
        void parseHeader();
        void parseOptObjective();
        void parseConstraint();
        void parseSum();
        void parseTerm();
        PBBuilder* builder_;
        weight_t   minCost_;
        weight_t   maxCost_;
        struct Constraint {
                WeightLitVec lits;
                weight_t     bound;
                bool         eq;
        }          active_;
        LitVec     term_;
};
// StreamSource
class StreamSource {
public:
        explicit StreamSource(std::istream& is);
        char operator*() {
                if (buffer_[pos_] == 0) { underflow(); }
                return buffer_[pos_];
        }
        StreamSource& operator++() { ++pos_; **this; return *this; }
        

        bool parseInt(int& val);
        bool parseInt64(int64& val);
        bool parseInt(int& val, int min, int max);
        int  parseInt(int min, int max, const char* err) {
                int x;
                return parseInt(x, min, max) ? x : (error(err ? err : "Integer expected!"), 0);
        }

        bool match(char c) { return (**this == c) && (++*this, true); }

        bool matchEol();
        bool skipSpace() { while (match(' ') || match('\t')) { ; } return true; }
        bool skipWhite() { do { skipSpace(); } while (matchEol()); return true; }
        unsigned line() const { return line_; }

        void error(const char* err) const { throw ParseError(line(), err); }
private:
        StreamSource(const std::istream&);
        StreamSource& operator=(const StreamSource&);
        void underflow();
        char buffer_[2048];
        std::istream& in_;
        unsigned pos_;
        unsigned line_;
};
inline void skipLine(StreamSource& in) { while (*in && !in.matchEol()) { ++in; } }


inline bool match(StreamSource& in, char c, bool sw) { return (!sw || in.skipSpace()) && in.match(c); }


inline bool match(StreamSource& in, const char* str, bool sw) {
        if (sw) in.skipSpace();
        while (*str && in.match(*str)) { ++str; }
        return *str == 0;
}

inline bool matchEol(StreamSource& in, bool sw) {
        if (sw) in.skipSpace();
        return in.matchEol();
}


bool readLine( StreamSource& in, PodVector<char>::type& buf );

}
#endif