location.hpp

Go to the documentation of this file.

// A Bison parser, made by GNU Bison 3.0.2.
 
// Locations for Bison parsers in C++
 
// Copyright (C) 2002-2013 Free Software Foundation, Inc.
 
// 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 3 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/>.
 
// As a special exception, you may create a larger work that contains
// part or all of the Bison parser skeleton and distribute that work
// under terms of your choice, so long as that work isn't itself a
// parser generator using the skeleton or a modified version thereof
// as a parser skeleton.  Alternatively, if you modify or redistribute
// the parser skeleton itself, you may (at your option) remove this
// special exception, which will cause the skeleton and the resulting
// Bison output files to be licensed under the GNU General Public
// License without this special exception.
 
// This special exception was added by the Free Software Foundation in
// version 2.2 of Bison.
 
// This version for ztsdb is lightly modified from the original
// Bison-generated location/position files. Mainly, we add a
// shared_ptr to the buffer being parsed in the 'position' class, and
// make sure the addition of this element if properly handled by the
// constructors.
 
#ifndef YY_YY_LOCATION_HH_INCLUDED
# define YY_YY_LOCATION_HH_INCLUDED
 
#include <memory>
#include <string>
#include "position.hpp"
 
 
namespace yy {
  class location
  {
  public:
 
    location (const position& b, 
              const position& e)
      : begin(b)
      , end(e)
    {
    }
 
    explicit location (const position& p = position ())
      : begin(p)
      , end(p)
    {
    }
 
    explicit location (const std::string& filename_p,
                       unsigned int l = 1u,
                       unsigned int c = 1u,
                       std::shared_ptr<const std::string> s_p = 
                         std::make_shared<const std::string>())
      : begin(filename_p, l, c, s_p)
      , end(filename_p, l, c, s_p)
    {
    }
 
    void initialize(const std::string& filename_p, 
                    unsigned int l,
                    unsigned int c,
                    std::shared_ptr<const std::string> s_p)
    {
      begin.initialize(filename_p, l, c, s_p);
      end = begin;
    }
 
  public:
    void step ()
    {
      begin = end;
    }
 
    void columns (int count = 1)
    {
      end += count;
    }
 
    void lines (int count = 1)
    {
      end.lines (count);
    }
  public:
    position begin;
    position end;
  };
 
  inline location operator+ (location res, const location& end)
  {
    res.end = end.end;
    return res;
  }
 
  inline location& operator+= (location& res, int width)
  {
    res.columns (width);
    return res;
  }
 
  inline location operator+ (location res, int width)
  {
    return res += width;
  }
 
  inline location& operator-= (location& res, int width)
  {
    return res += -width;
  }
 
  inline location operator- (const location& begin, int width)
  {
    return begin + -width;
  }
 
  inline bool
  operator== (const location& loc1, const location& loc2)
  {
    return loc1.begin == loc2.begin && loc1.end == loc2.end;
  }
 
  inline bool
  operator!= (const location& loc1, const location& loc2)
  {
    return !(loc1 == loc2);
  }
 
  template <typename YYChar>
  inline std::basic_ostream<YYChar>&
  operator<< (std::basic_ostream<YYChar>& ostr, const location& loc)
  {
    unsigned int end_col = 0 < loc.end.column ? loc.end.column - 1 : 0;
    ostr << loc.begin// << "(" << loc.end << ") "
;
    if (!loc.end.filename.empty()
        && (loc.begin.filename.empty()
            || loc.begin.filename != loc.end.filename))
      ostr << '-' << loc.end.filename << ':' << loc.end.line << '.' << end_col;
    else if (loc.begin.line < loc.end.line)
      ostr << '-' << loc.end.line << '.' << end_col;
    else if (loc.begin.column < end_col)
      ostr << '-' << end_col;
    return ostr;
  }
 
  inline location missing_loc() {
    return location("", 0, 0, std::make_shared<const std::string>());
  }
  inline location span_loc(const location& b, const location& e) {
    return location(b.begin, e.end);
  }
} // yy
#endif // !YY_YY_LOCATION_HH_INCLUDED