---

parse_util.hh

Go to the documentation of this file.

/*
 *  File:       parse_util.hh
 *              $Id: parse_util.hh,v 1.7 2002/06/26 20:49:08 alec Exp $
 *
 *  Author:     Alec Panoviciu (alecu@email.com)
 *
 *  Comments:
 *
 *  Revision history:
 *
 *  $Log: parse_util.hh,v $
 *  Revision 1.7  2002/06/26 20:49:08  alec
 *  g++ 3.x happy
 *
 *  Revision 1.6  2002/06/23 23:29:21  alec
 *  profile-based optimization stuff
 *
 *  Revision 1.5  2002/06/13 11:40:48  alec
 *  added #line stuff
 *
 *  Revision 1.4  2002/04/29 17:55:41  alec
 *  regexps almost done
 *
 *  Revision 1.3  2002/04/29 09:34:10  alec
 *  scanner ptree building compiles
 *
 */


/* 
  Copyright (C) 2002 Alexandru Panoviciu (alecu@email.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, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

#ifndef __PARSE_UTIL_HH__
#define __PARSE_UTIL_HH__

#include <stdexcept>
#include <iostream>
#include <string>
using namespace std;

typedef struct t_Position
{
  int ln;
  int col;

  t_Position (int ln_, int col_ = 0) :
    ln(ln_), col(col_)
  {}

  t_Position () : ln(0), col(0)
  {}
  
} Position;


typedef struct t_CodeChunk
{
  Position pos;
  string code;

  t_CodeChunk () {}

  t_CodeChunk (const t_CodeChunk &o) :
    pos(o.pos), code(o.code)
  {}

  t_CodeChunk (const Position &pos_, const string &code_) :
    pos(pos_), code(code_)
  {}

  t_CodeChunk& operator = (const struct t_CodeChunk &o)
  {
    pos = o.pos;
    code = o.code;
    return *this;
  }

  void set (const string &code_, const Position &pos_)
  {
    code = code_;
    pos = pos_;
  }

  int countLines () const
  {
    int res = 1, i = 0;
    while ((i = code.find('\n', i)) != string::npos) res++, i++;
    return res;
  }

  bool empty() const { return code.size() == 0; }
  
} CodeChunk;

inline ostream& operator << (ostream &os, const Position &pos)
{
  os << pos.ln;
  if (pos.col != 0) os << ":" << pos.col;
  return os;
}

class ParseException : public exception
{
public:

  ParseException (const string &message_) :
    message(message_),
    pos()
  {}
  
  ParseException () :
    message("Bad option"),
    pos()
  {}

  ParseException (const Position &pos_, const string &message_) :
    message(message_),
    pos(pos_)
  {}

  ~ParseException () throw ()
  {}

  virtual const char* what() const throw()
  {
    return message.c_str();
  }

  virtual operator string() const
  {
    return message;
  }

  const Position& where() const
  {
    return pos;
  }

  
protected:
  
  string message;
  Position pos;
};


string formatError (const Position& pos, const string &message);


string formatError (const string &message);


string formatError (const ParseException &ex);

string formatWarning (const Position& pos, const string &message);

string formatWarning (const string &message);


void die (const string &message);

#endif /* #ifndef __PARSE_UTIL_HH__ */

---