Scanner.h

Go to the documentation of this file.

/* Frobby: Software for monomial ideal computations.
   Copyright (C) 2007 Bjarke Hammersholt Roune (www.broune.com)
 
   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 option) 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, see http://www.gnu.org/licenses/.
*/
#ifndef SCANNER_GUARD
#define SCANNER_GUARD
 
#include "VarNames.h"
#include <string>
 
class IOHandler;
 
class Scanner {
public:
  Scanner(const string& formatName, FILE* in);
  ~Scanner() {delete[] _tmpString;}
 
  const string& getFormat() const {return _formatName;}
  void setFormat(const string& format) {_formatName = format;}
  auto_ptr<IOHandler> createIOHandler() const;
 
  bool match(char c);
 
  bool matchEOF();
 
  void expect(char expected);
 
  void expect(char a, char b);
 
  void expect(const char* str);
 
  void expect(const string& str) {expect(str.c_str());}
 
  void expectEOF();
 
  void expectIntegerNoSign();
 
  void readInteger(mpz_class& integer);
 
  void readIntegerNoSign(string& str);
 
  void readIntegerNoSign(mpz_class& str);
 
  void readIntegerAndNegativeAsZero(mpz_class& integer);
 
  void readIntegerAndNegativeAsZero(std::string& integer);
 
  void readSizeT(size_t& size);
 
  const char* readIdentifier();
 
  void readIdentifier(string& str);
 
  size_t readVariable(const VarNames& names);
 
  bool peekIdentifier();
 
  bool peekWhite() {return isspace(peek());}
 
  bool peek(char character);
 
  unsigned int getLineNumber() const {return _lineNumber;}
 
  int peek() {return _char;}
 
  inline void eatWhite();
 
private:
  size_t readIntegerString();
 
  size_t readIntegerStringNoSign();
 
  void parseInteger(mpz_class& integer, size_t size);
 
  void errorExpectTwo(char a, char b, int got);
  void errorExpectOne(char expected, int got);
  void errorReadVariable(const char* name);
  void errorReadIdentifier();
 
  void reportErrorUnexpectedToken(const string& expected, int got);
  void reportErrorUnexpectedToken(const string& expected, const string& got);
 
  inline int getChar();
  void growTmpString();
  int readBuffer();
 
  mpz_class _integer;
  FILE* _in;
  unsigned long _lineNumber;
  int _char; // next character on stream
 
  char* _tmpString;
  size_t _tmpStringCapacity;
 
  string _formatName;
 
  vector<char> _buffer;
  vector<char>::iterator _bufferPos;
};
 
 
 
inline void Scanner::readIdentifier(string& str) {
  eatWhite();
  if (!isalpha(peek()))
    errorReadIdentifier();
  str.clear();
  do {
    str += static_cast<char>(getChar());
  } while (isalnum(peek()) || peek() == '_');
}
 
inline size_t Scanner::readVariable(const VarNames& names) {
  const char* name = readIdentifier();
  size_t var = names.getIndex(name);
  if (var == VarNames::invalidIndex)
    errorReadVariable(name);
  return var;
}
 
 
inline bool Scanner::matchEOF() {
  eatWhite();
  return peek() == EOF;
}
 
inline bool Scanner::match(char c) {
  eatWhite();
  if (c == peek()) {
    getChar();
    return true;
  } else
    return false;
}
 
inline void Scanner::expect(char a, char b) {
  eatWhite();
  int got = getChar();
  if (got != a && got != b)
    errorExpectTwo(a, b, got);
}
 
inline void Scanner::expect(char expected) {
  eatWhite();
  int got = getChar();
  if (got != expected)
    errorExpectOne(expected, got);
}
 
inline void Scanner::readInteger(mpz_class& integer) {
  size_t size = readIntegerString();
  parseInteger(integer, size);
}
 
inline void Scanner::expectIntegerNoSign() {
  readIntegerStringNoSign();
}
 
inline void Scanner::readIntegerNoSign(mpz_class& integer) {
  readIntegerStringNoSign();
  integer = _tmpString;
}
 
inline void Scanner::readIntegerNoSign(string& integer) {
  readIntegerStringNoSign();
  integer = _tmpString;
}
 
inline bool Scanner::peekIdentifier() {
  eatWhite();
  return isalpha(peek());
}
 
inline bool Scanner::peek(char character) {
  eatWhite();
  return peek() == character;
}
 
inline void Scanner::eatWhite() {
  while (isspace(peek()))
    getChar();
}
 
inline int Scanner::getChar() {
  if (_char == '\n')
    ++_lineNumber;
  int oldChar = _char;
  if (_bufferPos == _buffer.end())
    _char = readBuffer();
  else {
    _char = *_bufferPos;
    ++_bufferPos;
  }
  return oldChar;
}
 
#endif