baf_read.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 __BAF_READ_HH
# define __BAF_READ_HH

# include "../fast/invert_bits.hh"
# include "term.hh"
# include "constructor.hh"
# include <fstream>
# include <sstream>
# include <cstdlib>

# include <aurelia-config.hh>

# define BAF_MAGIC       0xbaf
# define BAF_VERSION     0x0300
# define INT_SIZE_IN_BAF 32

namespace aurelia {

struct baf_istream {
  std::istream& stream;
  baf_istream(std::istream& in): stream(in), bits_in_buffer(0) {
    in.exceptions(std::istream::eofbit
                  | std::ifstream::failbit
                  | std::ifstream::badbit);
  }

private:
  int bit_buffer;
  int bits_in_buffer;

public:
  void flush_bits() {
    bits_in_buffer = 0;
  }

  void read_bits(int nr_bits, unsigned &val) {
    val = 0;
    if (nr_bits <= 2) {
      int mask = 1;
      for (int cur_bit = 0; cur_bit < nr_bits; ++cur_bit) {
        if (bits_in_buffer == 0) {
          stream.read((char*)&bit_buffer, 1);
          bits_in_buffer = 8;
        }
        val |= ((bit_buffer << (8-bits_in_buffer)) & 0x80 ? mask : 0);
        mask <<= 1;
        bits_in_buffer--;
      }
      return ;
    }

    int shift = INT_SIZE_IN_BAF;
    while (nr_bits > 0) {
      if (bits_in_buffer == 0) {
        bits_in_buffer = (nr_bits+7)/8;
        bit_buffer = 0;
#ifdef WORDS_BIGENDIAN
        stream.read((char*)&bit_buffer, bits_in_buffer);
#else
        stream.read(((char*)&bit_buffer)+4-bits_in_buffer, bits_in_buffer);
        char a = ((char*)&bit_buffer)[0];
        ((char*)&bit_buffer)[0] = ((char*)&bit_buffer)[3];
        ((char*)&bit_buffer)[3] = a;
        a = ((char*)&bit_buffer)[1];
        ((char*)&bit_buffer)[1] = ((char*)&bit_buffer)[2];
        ((char*)&bit_buffer)[2] = a;
#endif
        bits_in_buffer *= 8;
      }
      if (nr_bits >= bits_in_buffer) {
        shift -= bits_in_buffer;
        if (bits_in_buffer == 32)
          val |= bit_buffer << shift;
        else
          val |= ((~(-1<<bits_in_buffer)) & bit_buffer) << shift;
        nr_bits -= bits_in_buffer;
        bits_in_buffer = 0;
      } else {
        shift -= nr_bits;
        if (bits_in_buffer == 32)
          val |= (bit_buffer >> (bits_in_buffer - nr_bits)) << shift;
        else
          val |= ((~(-1<<bits_in_buffer)) & (bit_buffer >> (bits_in_buffer - nr_bits))) << shift;
        bits_in_buffer -= nr_bits;
        nr_bits = 0;
      }
    }
    fast::invert_bits(val);
  }
};

baf_istream& operator>>(baf_istream& s, unsigned int& val) {
  unsigned char c0;
  s.stream.read((char*)&c0, 1);
  if ((c0 & 0x80) == 0) {
    val = c0;
    return s;
  }

  unsigned char c1;
  s.stream.read((char*)&c1,1);

  if ((c0 & 0x40) == 0) {
    val = c1 + ((c0 & ~0xc0) << 8);
    return s;
  }

  unsigned char c2;
  s.stream.read((char*)&c2,1);

  if ((c0 & 0x20) == 0) {
    val = c2 + (c1 << 8) + ((c0 & ~0xe0) << 16);
    return s;
  }

  unsigned char c3;
  s.stream.read((char*)&c3,1);

  if ((c0 & 0x10) == 0) {
    val = c3 + (c2 << 8) + (c1 << 16) +
      ((c0 & ~0xf0) << 24);
    return s;
  }

  unsigned char c4;
  s.stream.read((char*)&c4,1);
  val = c4 + (c3 << 8) + (c2 << 16) + (c1 << 24);
  return s;
}

baf_istream& operator>>(baf_istream& s, int& val) {
  s >> (unsigned&)val;
  return s;
}

baf_istream& operator>>(baf_istream& s, std::string& val) {
  unsigned len;
  s >> len;

  char c;
  for (unsigned i = 0; i < len; ++i) {
    s.stream.read(&c,1);
    val += c;
  }
  return s;
}

template <typename pool>
struct sym_read_entry
{
  untyped_constructor<pool>*   sym;
  unsigned    arity;
  unsigned   nr_terms;
  int    term_width;
  untyped_term<pool> **terms;
  unsigned *nr_topsyms;
  int   *sym_width;
  int  **topsyms;

  sym_read_entry() {
    sym = NULL;
    terms = NULL;
    nr_topsyms = NULL;
    sym_width = NULL;
    topsyms = NULL;
  }

  ~sym_read_entry() {
    delete sym;
    if (terms != NULL) {
      for (unsigned i = 0; i < nr_terms; ++i) {
        delete terms[i];
      }
      delete[] terms;
    }
    if (sym_width != NULL)
      delete[] sym_width;
    if (topsyms != NULL) {
      for (unsigned i = 0; i < arity; ++i) {
        if (topsyms[i] != NULL) {
          delete[] topsyms[i];
        }
      }
      delete[] topsyms;
    }
    if (nr_topsyms != NULL)
      delete[] nr_topsyms;
  }
};

unsigned bit_width(unsigned val)
{
  unsigned nr_bits = 0;

  if (val <= 1)
    return 0;

  while (val) {
    val>>=1;
    nr_bits++;
  }

  return nr_bits;
}

struct bad_format {};

template<typename pool>
untyped_term<pool>* read_term(sym_read_entry<pool>* read_symbols, int top,
                     baf_istream& st) {
  unsigned val;
  sym_read_entry<pool>* t = read_symbols + top;
  untyped_term<pool>* args = NULL;
  if ((t->arity))
    args = (untyped_term<pool>*)malloc((t->arity)*sizeof(untyped_term<pool>));

  unsigned i=0;
  try {
    for (; i <  t->arity; ++i) {
      st.read_bits(t->sym_width[i], val);
      if (val >= t->nr_topsyms[i]) {
        throw bad_format();
      }
      unsigned argn = t->topsyms[i][val];
      sym_read_entry<pool>* arg = &read_symbols[argn];
      st.read_bits(arg->term_width, val);
      if (val >= arg->nr_terms) {
        throw bad_format();
      }
      if (!arg->terms[val]) {
        arg->terms[val] = read_term(read_symbols, argn, st);
      }
      new (args+i) untyped_term<pool>(*arg->terms[val]);
    }

    if (untyped_constructor<pool>::AS_INT == *(t->sym)) {
      st.read_bits(INT_SIZE_IN_BAF, val);
      std::stringstream os;
      os << val;
      if (args != NULL)
        throw bad_format();
      return new untyped_term<pool>(untyped_constructor<pool>(os.str(), 0), NULL);
    } else if (untyped_constructor<pool>::AS_REAL == *(t->sym)) {
      st.flush_bits();
      std::string s;
      st >> s;
      if (args != NULL)
        throw bad_format();
      return new untyped_term<pool>(untyped_constructor<pool>(s, 0), NULL);
    } else if (untyped_constructor<pool>::AS_BLOB == *(t->sym)) {
      st.flush_bits();
      std::string s;
      st >> s;
      if (args != NULL)
        throw bad_format();
      return new untyped_term<pool>(untyped_constructor<pool>(s, 0), NULL);
    }
  }
  catch (...) {
    for (unsigned j = 0; j < i; ++j) {
      (args+j)->~untyped_term<pool>();
    }
    free(args);
    throw ;
  }

  return new untyped_term<pool>(*(t->sym), args);
}

template <typename pool>
untyped_term<pool> read_baf(const pool&, std::istream& in)
{
  unsigned val;
  baf_istream st(in);

  st >> val;
  if (val == 0)
    st >> val;
  if (val != BAF_MAGIC) {
    throw bad_format();
  }
  st >> val;
  if (val != BAF_VERSION) {
    throw bad_format();
  }
  unsigned nr_unique_symbols;
  st >> nr_unique_symbols;
  unsigned nr_unique_terms;
  st >> nr_unique_terms;
  sym_read_entry<pool>* read_symbols =
    new sym_read_entry<pool>[nr_unique_symbols];
  untyped_term<pool>* pret;
  try {
    for (unsigned i = 0; i < nr_unique_symbols; ++i) {
      std::string s;
      st >> s;
      st >> read_symbols[i].arity;
      st >> val;
      if (val) {
        s = "\"" + s + "\"";
      }
      read_symbols[i].sym = new untyped_constructor<pool>(s, read_symbols[i].arity);
      st >> read_symbols[i].nr_terms;
      read_symbols[i].term_width = bit_width(read_symbols[i].nr_terms);
      read_symbols[i].terms = new untyped_term<pool>*[read_symbols[i].nr_terms];
      for (unsigned j = 0; j < read_symbols[i].nr_terms; ++j)
        read_symbols[i].terms[j] = NULL;
      if (read_symbols[i].arity == 0) {
      } else {
        read_symbols[i].nr_topsyms = new unsigned[read_symbols[i].arity];
        read_symbols[i].sym_width = new int[read_symbols[i].arity];
        read_symbols[i].topsyms = new int*[read_symbols[i].arity];
        for (unsigned j = 0; j < read_symbols[i].arity; ++j) {
          read_symbols[i].topsyms[j] = NULL;
        }
        for (unsigned j = 0; j < read_symbols[i].arity; ++j) {
          st >> val;
          read_symbols[i].nr_topsyms[j] = val;
          read_symbols[i].sym_width[j] = bit_width(val);
          read_symbols[i].topsyms[j] = new int[val];
          for (unsigned k=0; k < read_symbols[i].nr_topsyms[j]; ++k) {
            st >> read_symbols[i].topsyms[j][k];
          }
        }
      }
    }

    st >> val;
    pret = read_term<pool>(read_symbols, val, st);
  }
  catch (...) {
    delete[] read_symbols;
    throw ;
  }

  untyped_term<pool> ret(*pret);
  delete pret;
  delete[] read_symbols;
  return ret;
}

}

#endif