include/basix/literal.hpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : literal.hpp
* DESCRIPTION: Atomic literals
* COPYRIGHT  : (C) 2005  Joris van der Hoeven
*******************************************************************************
* This software falls under the GNU general public license and comes WITHOUT
* ANY WARRANTY WHATSOEVER. See the file $TEXMACS_PATH/LICENSE for more details.
* If you don't have this file, write to the Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
******************************************************************************/

#ifndef __LITERAL_HPP
#define __LITERAL_HPP
#include <basix/port.hpp>
#include <basix/symbol.hpp>


namespace mmx {

/******************************************************************************
* Literals
******************************************************************************/

class literal {
MMX_ALLOCATORS
  string s;
  symbol<string> sym;
public:
  inline string operator * () const { return s; }
  inline friend string as_string (const literal& l) { return l.s; }
  inline friend symbol<string> as_symbol (const literal& s) { return s.sym; }
  inline literal (): s (""), sym (s) {}
  inline literal (const char *s2): s (string (s2)), sym (s) {}
  inline literal (const string& s2): s (s2), sym (s) {}
  inline literal (const literal& l): s (l.s), sym (l.sym) {}
  inline literal (const symbol<string>& sym2): s (*sym2), sym (sym2) {}
};

inline nat hash (const literal& c) { return hash (as_symbol (c)); }
inline nat exact_hash (const literal& c) { return exact_hash (as_symbol (c)); }
inline nat hard_hash (const literal& c) { return hard_hash (as_string (c)); }
inline bool operator == (const literal& c1, const literal& c2) {
  return as_symbol (c1) == as_symbol (c2); }
inline bool operator != (const literal& c1, const literal& c2) {
  return as_symbol (c1) != as_symbol (c2); }
inline bool exact_eq (const literal& c1, const literal& c2) {
  return exact_eq (as_symbol (c1), as_symbol (c2)); }
inline bool exact_neq (const literal& c1, const literal& c2) {
  return exact_neq (as_symbol (c1), as_symbol (c2)); }
inline bool hard_eq (const literal& c1, const literal& c2) {
  return hard_eq (as_string (c1), as_string (c2)); }
inline bool hard_neq (const literal& c1, const literal& c2) {
  return hard_neq (as_string (c1), as_string (c2)); }

template<typename C> C
make_literal (const literal& lit) {
  return C (as_string (lit));
}

string literal_to_string (const generic& g);
syntactic flatten (const literal& s);

template<>
struct binary_helper<literal>: public void_binary_helper<literal> {
  static inline string short_type_name () { return "L"; }
  static inline generic full_type_name () { return "Literal"; }
  static inline generic disassemble (const literal& x) {
    return as<generic> (*x); }
  static inline literal assemble (const generic& x) {
    return literal (as<string> (x)); }
  static inline void write (const port& out, const literal& l) {
    binary_write<string> (out, as_string (l)); }
  static inline literal read (const port& in) {
    return literal (binary_read<string> (in)); }
};

bool is_literal_string (const literal& l);
bool is_literal_int (const literal& l);
bool is_literal_double (const literal& l);
string as_literal_string (const literal& l);
int as_literal_int (const literal& l);
double as_literal_double (const literal& l);

} // namespace mmx
#endif // __LITERAL_HPP

---