Scanner.h

Go to the documentation of this file.

/*
 * Copyright (C) 2008 Kamil Dudka <xdudka00@stud.fit.vutbr.cz>
 *
 * This file is part of fss (Fast SAT Solver).
 *
 * fss 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
 * any later version.
 *
 * fss 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 fss.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef SCANNER_H
#define SCANNER_H

# include <iostream>

namespace FastSatSolver {
  class VariableContainer;
  class FormulaContainer;

  enum EToken {
    T_VARIABLE,           
    T_FALSE,              
    T_TRUE,               
    T_NOT,                
    T_AND,                
    T_OR,                 
    T_XOR,                
    T_LPAR,               
    T_RPAR,               
    T_DELIM,              
    T_EOF,                
    T_STRING,             

    T_STACK_BOTTOM,       
    T_PARSER_EXPR,        
    T_PARSER_EQ,          
    T_PARSER_LT,          
    T_PARSER_GT,          
    T_PARSER_INV,         
    T_ERR_LEX = -1,       
    T_ERR_EXPR = -2,
    T_ERR_PARSE = -3
  };


  struct Token {
    int           m_line;         

    EToken        m_token;        
    int           m_ext_number;   
    std::string   m_ext_text;     

    Token() { }

    Token(EToken e): m_line(0), m_token(e), m_ext_number(0) { }
  };

  // For debugging and/or error reporting purposes
  inline std::ostream& operator<< (std::ostream &stream, EToken e) {
    switch (e) {
      case T_EOF:         stream << "T_EOF";          break;
      case T_FALSE:       stream << "T_FALSE";        break;
      case T_TRUE:        stream << "T_TRUE";         break;
      case T_NOT:         stream << "T_NOT";          break;
      case T_AND:         stream << "T_AND";          break;
      case T_OR:          stream << "T_OR";           break;
      case T_XOR:         stream << "T_XOR";          break;
      case T_LPAR:        stream << "T_LPAR";         break;
      case T_RPAR:        stream << "T_RPAR";         break;
      case T_DELIM:       stream << "T_DELIM";        break;
      case T_STRING:      stream << "T_STRING";       break;
      case T_VARIABLE:    stream << "T_VARIABLE";     break;
      case T_STACK_BOTTOM:stream << "T_STACK_BOTTOM"; break;
      case T_PARSER_EXPR: stream << "T_PARSER_EXPR";  break;
      case T_PARSER_EQ:   stream << "T_PARSER_EQ";    break;
      case T_PARSER_LT:   stream << "T_PARSER_LT";    break;
      case T_PARSER_GT:   stream << "T_PARSER_GT";    break;
      case T_PARSER_INV:  stream << "T_PARSER_INV";   break;
      case T_ERR_LEX:     stream << "T_ERR_LEX";      break;
      case T_ERR_EXPR:    stream << "T_ERR_EXPR";     break;
      case T_ERR_PARSE:   stream << "T_ERR_PARSE";    break;
      default:            stream << e;                break;
    }
    return stream;
  }

  // For debugging and/or error reporting purposes
  inline std::ostream& operator<< (std::ostream &stream, Token token) {
    stream << "Token: " << token.m_token << std::endl;
    if (token.m_line)
      stream << "       At line: " << token.m_line  << std::endl;
    if (T_VARIABLE == token.m_token) {
      stream << " Variable name: " << token.m_ext_text << std::endl;
      stream << "   Vairable id: " << token.m_ext_number << std::endl;
    }
    return stream;
  }

  class IScanner
  {
    public:
      virtual ~IScanner() { }

      virtual int readNext (Token* token ) = 0;
  };

  class RawScanner : public IScanner
  {
    public:
      RawScanner (FILE* fd );
      virtual ~RawScanner();
      
      // see IScanner dox
      virtual int readNext (Token* token );

    private:
      struct Private;
      Private *d;
  };

  class ScannerStringHandler : public IScanner
  {
    public:
      ScannerStringHandler (IScanner *scanner, VariableContainer *vc );
      virtual ~ScannerStringHandler();

      // see IScanner dox
      virtual int readNext (Token* token );

    private:
      struct Private;
      Private *d;
  };

  class ScannerFormulaHandler : public IScanner
  {
    public:
      ScannerFormulaHandler (IScanner *scanner, FormulaContainer *fc );
      virtual ~ScannerFormulaHandler();

      // see IScanner dox
      virtual int readNext (Token* token );

    private:
      struct Private;
      Private *d;
  };

} // namespace FastSatSolver


#endif // SCANNER_H

---