utils.hh

// This file is a part of Aurelia.
// Copyright (C) 2010  Valentin David
// Copyright (C) 2010  University of Bergen
//
// 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/>.

#ifndef __UTILS_HH
# define __UTILS_HH

extern const unsigned char first[][32];
extern const unsigned char empty_first[];
extern const unsigned char follow[][32];

bool is_first(const stream& s, state alpha) {
  char c = *s;
  return (first[alpha][c>>3]&(1<<(c&7)))?true:false;
}

bool is_empty_first(state alpha) {
  return (empty_first[alpha>>3]&(1<<(alpha&7)))?true:false;
}

bool is_follow(const stream& s, nonterm A) {
  if (s.eof())
    return true;
  char c = *s;
  return (follow[A][c>>3]&(1<<(c&7)))?true:false;
}

bool test(const stream& s, nonterm A, state alpha) {
  if ((is_empty_first(alpha)) && (is_follow(s, A)))
    return true;
  if (!s.eof())
    if (is_first(s, alpha))
      return true;
  return false;
}

template <typename T, int branch_num, int label_num>
struct branch {
};

template <typename Label, typename Ret = void_return>
struct drop_ret {
public:
  void operator()(r_t& R, const frame& f, stream& s, const node& cu) const {
    ret_frame<Ret> t = f.as<ret_frame<Ret> >();
    Label l;
    l(R, t.parent, s, cu);
  }

  unsigned hash() const {
    Label l;
    unsigned ret = (0x8934931a ^ l.hash());
    ret = (ret << 11) | (ret >> 21);
    return ret;
  }
};

template <typename S, state C, typename Next>
struct parse_symbol {
  void operator()(r_t& R, const frame& f, stream& s, const node& cu) const {
    //std::cerr << "Calling: " << C << ":" << s.get_pos() << " " << typeid(S).name() << "(" << f.toString() << ")" << std::endl;
    if (test(s, (nonterm)S::NT, C)) {
      node ncu = node::create(R, typename Next::res(), f, cu, s);
      S sym;
      sym(R, f, s, ncu);
    }
  }

  unsigned hash() const {
    return (unsigned)&typeid(parse_symbol);
  }
};

template <typename string, typename Next>
struct parse_string {
  void operator()(r_t& R, const frame& f, stream& s, const node& cu) const {
    //std::cerr << "Eating: " << C << ":" << s.get_pos() << " " << string::str << std::endl;
    if (s.eat(string::str)) {
      //std::cerr << "Success: " << s.get_pos() << std::endl;
      typename Next::res n;
      n(R, f, s, cu);
    }
  }

  unsigned hash() const {
    return (unsigned)&typeid(parse_string);
  }
};

template <typename NT>
struct nofollow {
  static bool check(stream&) {
    return false;
  }
};

template <typename S>
struct pop {
  void operator()(r_t& R, const frame&, stream& s, const node& cu) const {
    //std::cout << "Pop: " << s.get_pos() << std::endl;
    cu.pop(R, void_return(), s);
  }

  unsigned hash() const {
    return (unsigned)&typeid(pop);
  }
};

template <typename S, typename Next>
struct parse_set {
  void operator()(r_t& R, const frame& f, stream& s, const node& cu) const {
    if (!s.eof()) {
      if (S::set[((unsigned char)*s)/8]&(1<<(((unsigned char)*s)%8))) {
        ++s;
        typename Next::res r;
        r(R, f, s, cu);
      }
    }
  }

  unsigned hash() const {
    return (unsigned)&typeid(parse_set);
  }
};

#endif