---

semantics_delta.h

Go to the documentation of this file.

// Semantics Delta implementation -*- C++ -*-

// Copyright (C) 2001-2003 Hermann Schichl
//
// This file is part of the COCONUT API.  This library
// is free software; you can redistribute it and/or modify it under the
// terms of the Library GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.

// This library 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
// Library GNU General Public License for more details.

// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the Library GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the Library GNU General Public License.

#ifndef _SEMANTICS_DELTA_H_
#define _SEMANTICS_DELTA_H_

#include <api_delta.h>

class semantics_undelta : public undelta_base
{
private:
  std::vector<unsigned int> indices;    // if all variables are being
                                        // updated this vector is empty
  std::vector<uint32_t> old_f_sem;      // original semantics are stored here
                                        // in order to restore the values
                                        // easily during backtracking
  // the coding is described in the semantics_delta class 
public:
  semantics_undelta(const std::vector<unsigned int>& __i,
                const std::vector<uint32_t>& __s) : undelta_base(),
                                                    indices(__i),
                                                    old_f_sem(__s) {}
  
  semantics_undelta(const std::vector<unsigned int>& __i) : undelta_base(),
                                                        indices(__i),
                                                        old_f_sem() {}
  
  semantics_undelta(const semantics_undelta& __d) : undelta_base(__d),
                                            indices(__d.indices),
                                            old_f_sem(__d.old_f_sem)
      {
#if DEBUG_DELTA
        std::cerr << "Called semantics_undelta copy constructor" << std::endl;
#endif
      }

  semantics_undelta* new_copy() const { return new semantics_undelta(*this); }
  void destroy_copy(semantics_undelta* __d) { delete __d; }

  bool unapply(work_node& _x) const;

  friend class semantics_delta;
};

class semantics_delta : public delta_base
{
private:
  std::vector<unsigned int> indices;         // if all variables are being
                                             // updated this vector is empty
  std::vector<uint32_t> new_f_sem;           // new semantics
private:
  bool search(unsigned int _i, std::vector<unsigned int>::iterator& _xs);
  
  uint32_t ebool(uint32_t e, bool b, int idx) const
    // e contains a base 3 number. bi == 3^idx (for 0,1,2 which are all poss.)
    // e = a_2*3^2+a_1*3^1+a_0
        { uint32_t bi = idx == 0 ? 1 : (idx == 1 ? 3 : 9);
          uint32_t s = e % (bi*3);  // s = sum_{i=0:idx} a_i*3^i
          if(idx != 0) s -= e % bi; // s = a_idx*bi
          return e - s + (b ? 2*bi : bi); // e - s + (0,1,2)*3^idx is the new v.
        }
  uint32_t etristate(const tristate& t) const
        { return t == t_true ? 1 : (t == t_false ? 3 : 2); }
  uint32_t econvex_e(const convex_e& c) const
        { return (c == c_concave ? 3 : (uint32_t) c.i()) | (c.t() << 16); }
  uint32_t etype_annotation(const type_annotation& a) const
        { return (uint32_t) a; }
  uint32_t eactivity_descr(const activity_descr& a) const
        { return (uint32_t) a; }
  
  void dbool(uint32_t c, bool &b, int idx) const
    // c contains a base 3 number. bi == 3^idx (for 0,1,2 which are all poss.)
    // c = a_2*3^2+a_1*3^1+a_0
        { uint32_t bi = idx == 0 ? 1 : (idx == 1 ? 3 : 9);
          uint32_t s = c % (bi*3);  // s = sum_{i=0:idx} a_i*3^i
          if(idx != 0) s -= c % bi; // s = a_idx*bi
          if(s)                     // a_idx != 0
            b = (s != bi);         // a_idx == 1 => F, a_idx == 2 => T
        }
  void dtristate(uint32_t c, tristate& t) const
        { if(c == 3) t = t_false; else if(c != 0) t = (tristate) c; }
  void dconvex_e(uint32_t c, convex_e& ce) const
        { uint16_t t = c >> 16;
          ce = t; c = c&0xffff;
          if(c == 3) ce = c_concave; else if(c != 0) ce = (convex_info) c; }
  void dtype_annotation(uint32_t c, type_annotation& a) const
        { a = (type_annotation) c; }
  void dactivity_descr(uint32_t c, activity_descr& a) const
        { if(c) a = (activity_descr) c; }
  
public:
  uint32_t encode_convex(uint32_t e, const convex_e& c) const
        { return (e & ~7) | econvex_e(c) | (1<<2); }
  uint32_t encode_activity(uint32_t e, const activity_descr& a) const
        { return (e & ~(7 << 3)) | (eactivity_descr(a)<<3); }
  uint32_t encode_is_at_any_bound(uint32_t e, bool b) const
        { return (e & ~(31 << 6)) | (ebool((e>>6)&31, b, 0)<<6); }
  uint32_t encode_integer(uint32_t e, bool b) const
        { return (e & ~(31 << 6)) | (ebool((e>>6)&31, b, 1)<<6); }
  uint32_t encode_hard(uint32_t e, bool b) const
        { return (e & ~(31 << 6)) | (ebool((e>>6)&31, b, 2)<<6); }
  uint32_t encode_separable(uint32_t e, const tristate& t) const
        { return (e & ~(3 << 11)) | (etristate(t)<<11); }
  uint32_t encode_type(uint32_t e, const type_annotation& a) const
        { return (e & ~(3 << 13)) | (etype_annotation(a)<<13) | (1<<15); }
  uint32_t encode(const semantics& s) const
        { uint32_t e(0);
          e = encode_convex(e, s.property_flags.c_info);
          e = encode_activity(e, s.property_flags.act);
          e = encode_separable(e, s.property_flags.separable);
          e = encode_is_at_any_bound(e, s.property_flags.is_at_any_bound);
          e = encode_integer(e, s.annotation_flags.integer);
          e = encode_type(e, s.annotation_flags.type);
          e = encode_hard(e, s.annotation_flags.hard);
          return e;
        }

  void decode_convex(uint32_t e, convex_e& c) const
        { if(e & (1<<2)) dconvex_e(e & 0xffff0003, c); }
  void decode_activity(uint32_t e, activity_descr& a) const
        { dactivity_descr((e>>3) & 7, a); }
  void decode_is_at_any_bound(uint32_t e, bool& b) const
        { dbool((e>>6) & 31, b, 0); }
  void decode_integer(uint32_t e, bool& b) const
        { dbool((e>>6) & 31, b, 1); }
  void decode_hard(uint32_t e, bool& b) const
        { dbool((e>>6) & 31, b, 2); }
  void decode_separable(uint32_t e, tristate& t) const
        { dtristate((e>>11) & 3, t); }
  void decode_type(uint32_t e, type_annotation& a) const
        { if(e & (1<<15)) dtype_annotation((e>>13) & 3, a); }
  void decode(uint32_t e, semantics& s) const
        {
          decode_convex(e, s.property_flags.c_info);
          decode_activity(e, s.property_flags.act);
          decode_separable(e, s.property_flags.separable);
          decode_is_at_any_bound(e, s.property_flags.is_at_any_bound);
          decode_integer(e, s.annotation_flags.integer);
          decode_type(e, s.annotation_flags.type);
          decode_hard(e, s.annotation_flags.hard);
        }

public:
  semantics_delta(const std::vector<unsigned int>& __i,
                  const std::vector<uint32_t>& __b);
  
  semantics_delta(unsigned int __i, uint32_t __b)
                    : delta_base("change semantics"), indices(1,__i),
                      new_f_sem(1,__b) {}
 
  semantics_delta() : delta_base("change semantics"), indices(), new_f_sem() {} 
  semantics_delta(const semantics_delta& __d)
                    : delta_base(__d), indices(__d.indices),
                      new_f_sem(__d.new_f_sem)
    {
#if DEBUG_DELTA
        std::cerr << "Called semantics_delta copy constructor" << std::endl;
#endif
    }

  semantics_delta* new_copy() const { return new semantics_delta(*this); }
  void destroy_copy(semantics_delta* __d) { delete __d; }

  void set(const std::vector<unsigned int>& _i,
           const std::vector<semantics>& _s);
  void set(const std::vector<unsigned int>& _i,
           const std::vector<uint32_t>& _s);
  void set(unsigned int _i, const semantics& _s);
  void set_convex(const std::vector<unsigned int>& _i,
                  const std::vector<convex_e>& c);
  void set_convex(unsigned int _i, const convex_e& c);
  void set_activity(const std::vector<unsigned int>& _i,
                  const std::vector<activity_descr>& a);
  void set_activity(unsigned int _i, const activity_descr& a);
  void set_separable(const std::vector<unsigned int>& _i,
                     const std::vector<tristate>& t);
  void set_separable(unsigned int _i, const tristate& t);
  void set_is_at_any_bound(const std::vector<unsigned int>& _i,
                           const std::vector<bool>& b);
  void set_is_at_any_bound(unsigned int _i, bool b);
  void set_integer(const std::vector<unsigned int>& _i,
                   const std::vector<bool>& b);
  void set_integer(unsigned int _i, bool b);
  void set_hard(const std::vector<unsigned int>& _i,
                const std::vector<bool>& b);
  void set_hard(unsigned int _i, bool b);
  void set_type(const std::vector<unsigned int>& _i,
                const std::vector<type_annotation>& a);
  void set_type(unsigned int _i, const type_annotation& a);

  bool apply(work_node& _x, undelta_base*& _u) const;

  friend class semantics_undelta;
};

#endif /* _SEMANTICS_DELTA_H_ */

---