pinapa-tree-decoration.h

Go to the documentation of this file.

/*******************************************************************************
 * arch-tag: Matthieu Moy  April 14, 2003 (parser/include/scp-tree-decoration.h)
 *------------------------------------------------------------------------------
 *         Copyright (c) STMicroelectronics,Verimag
 * Pinapa is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, 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 GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free
 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA
 *------------------------------------------------------------------------------
 *                 System Platform Group - HPC
 *******************************************************************************/

#include "pinapa-parser-all.h"

namespace pinapa {

  class st_tree_deco_t;
  typedef st_tree_deco_t * tree_deco_t;

  class st_dependant_deco;
  typedef st_dependant_deco * dependant_deco;

  class st_type_deco;
  typedef st_type_deco * type_deco;

  class st_data_member_decl_deco;
  typedef st_data_member_decl_deco * data_member_decl_deco;

  class st_event_tree_deco;
  typedef st_event_tree_deco * event_tree_deco;

  class st_inst_dependant_deco;
  typedef st_inst_dependant_deco * inst_dependant_deco;
}

#ifndef PINAPA_TREE_DECORATION_H
#define PINAPA_TREE_DECORATION_H

#define PINAPA_NO_DEBUG

#include <ext/hash_set>

#include "pinapa-hash.h"
#include "pinapa-tree.h"
#include "pinapa-tree-utils.h"
#include "pinapa-sensitivity-list.h"
#include "pinapa-systemc-light.h"
#include "pinapa-decoration-base.h"
#include "pinapa-c-value.h"
#include "pinapa-interface-plus.h"

namespace pinapa {
  
  typedef st_deco_first<st_tree_deco_t,
                        tree_node> st_tree_deco;
  typedef st_tree_deco * tree_deco;
  
}

#define PINAPA_BEGIN_DOX
#define PINAPA_END_DOX

#ifdef PINAPA_INSIDE_DOXYGEN
#define PINAPA_DECLARE_PRIMITIVE(prim, com) PINAPA_BEGIN_DOX com PINAPA_END_DOX prim,
#else
#define PINAPA_DECLARE_PRIMITIVE(prim, com) prim,
#endif

namespace pinapa {

  typedef enum {
#include "pinapa-primitives.def"
  } sc_primitive_t;
  
  char * get_name(sc_primitive_t prim);
  char * get_doc(sc_primitive_t prim);
  
  typedef enum {
    PINAPA_TLM_ADDRESS_TYPE, 
    PINAPA_TLM_DATA_TYPE, 
    PINAPA_STANDARD_TYPE 
  } type_of_type;


  extern hash_map<tree, tree_deco> tree_decoration_map;

  template<class deco>
  class st_deco_first<deco, tree_node> : public st_deco_b {
  public:
    st_deco_first<deco, tree_node>() {}
    st_deco_first<deco, tree_node>(deco d) : m_deco(d) {}
    st_deco_first<deco, tree_node>(sc_primitive_t p, tree t) : m_deco(p, t) {}
    static st_deco_first<deco, tree_node> & get(tree_node * p);
    static st_deco_first<deco, tree_node> * get_deco(tree_node * p);
    static bool is_null(tree_node * p) {
      return tree_decoration_map.find(p) == tree_decoration_map.end();}
    void attach(tree_node * p);
    deco * operator -> () {return & m_deco;}
    deco * get_deco() {return & m_deco;}
  private:
    deco m_deco;
  };

  template <class deco>
  inline st_deco_first<deco, tree_node> &
  st_deco_first<deco,tree_node>::get(tree_node * p) {
    st_deco_first<deco,tree_node> * res =
      tree_decoration_map[p];
    if (res == NULL) {
      res = new st_deco_first<deco,tree_node>(p);
      res->attach(p);
      (*res)->set_tree(p);
    }
    return *res;
  }

  template <class deco>
  inline st_deco_first<deco, tree_node> *
  st_deco_first<deco,tree_node>::get_deco(tree_node * p) {
    st_deco_first<deco,tree_node> * res =
      tree_decoration_map[p];
    return res;
  }

  template <class deco>
  void st_deco_first<deco,tree_node>::attach(tree_node * p){
    tree_decoration_map[p] = this;
    tree decoration = p->common.pinapa_decoration;
    while(decoration != NULL_TREE) {
      tree_decoration_map[TREE_VALUE(decoration)] = this;
      decoration = TREE_CHAIN(decoration);
    }
  }

  typedef st_deco_first<st_tree_deco_t,
                        tree_node> st_tree_deco;

  typedef st_tree_deco * tree_deco;

  struct hash_key_assoc_tree_handle;
  struct equal_to_key_assoc_tree_handle;

  class key_assoc_tree_handle {
    friend class equal_to_key_assoc_tree_handle;
    friend class hash_key_assoc_tree_handle;
  public:
    key_assoc_tree_handle(const tree t, const sc_process_b * h)
      : m_tree(t), m_handle(h) {}

    key_assoc_tree_handle(const key_assoc_tree_handle& k)
      : m_tree(k.m_tree), m_handle(k.m_handle) {}

    const tree m_tree;
    const sc_process_b * m_handle;

    key_assoc_tree_handle & operator=(const key_assoc_tree_handle & k) {
      key_assoc_tree_handle * assign = new key_assoc_tree_handle(k);
      return *assign;
    }
  };

  struct equal_to_key_assoc_tree_handle {
    bool operator()(const key_assoc_tree_handle k1,
                    const key_assoc_tree_handle k2) const {
      return ((k1.m_tree == k2.m_tree) && (k1.m_handle == k2.m_handle));
    }
  };

  struct hash_key_assoc_tree_handle {
    size_t operator () (const key_assoc_tree_handle k) const {
      hash<sc_process_b *> H1;
      hash<tree>           H2;

      // Hashing on pointer values.
      return H1(k.m_handle) + H2(k.m_tree);
    }
  };
  class st_tree_instance_deco_t {
  public:
    st_tree_instance_deco_t() : m_related_object(NULL),
                                m_initial_value(NULL),
                                m_deco(NULL) {}
    sc_object * get_related_object() const {return m_related_object;}
    void set_related_object(sc_object * r) {m_related_object = r;}
    hash_set<sc_interface *> get_channels() const {return m_channels;}
    sc_interface * get_channel() const {
      PINAPA_ASSERT(m_channels.size() == 1, "Only one channel currently allowed. Got " << m_channels.size());
      return *m_channels.begin();}
    void add_channel(sc_interface * c) {m_channels.insert(c);}
    tree get_initial_value() const {return m_initial_value;}
    void set_initial_value(tree i, tree attach);

    inst_dependant_deco get_dependant_deco() const {return m_deco;}
    void set_dependant_deco(inst_dependant_deco  d) {m_deco = d;}

  private:
    sc_object * m_related_object;
    hash_set<sc_interface *> m_channels;
    tree m_initial_value;
    inst_dependant_deco m_deco;
  };

  template<>
  void * get_decoration<key_assoc_tree_handle>
  (key_assoc_tree_handle & th);

  template<>
  void set_decoration<key_assoc_tree_handle>
  (key_assoc_tree_handle & th, void * d);


  typedef st_deco_first<st_tree_instance_deco_t,
                        key_assoc_tree_handle> st_tree_instance_deco;

  typedef st_tree_instance_deco * tree_instance_deco;

  typedef hash_map<key_assoc_tree_handle,
                   tree_instance_deco,
                   hash_key_assoc_tree_handle,
                   equal_to_key_assoc_tree_handle > assoc_tree_handle;
  extern assoc_tree_handle instances_deco;

#ifdef PINAPA_GDB
  void gdb_dump_instance_deco();
#endif

  class st_tree_deco_t {

    static bool may_require_warning;

  public:
    static tree_deco get(tree body);

    static sc_primitive_t get_primitive(tree body) {
      return get(body) == NULL ? CPP_STANDARD : (*get(body))->get_primitive();}

    static void initialize(tree body) {
      if (tree_decoration_map.find(body) == tree_decoration_map.end()) {
        tree_decoration_map[body] = NULL;
      }
    }
    st_tree_deco_t(sc_primitive_t sc_primitive, tree t);

    st_tree_deco_t(tree t);

  public:

    sc_primitive_t get_primitive() const {return m_primitive;}
    sc_object * get_related_object(sc_process_b * h) const {
      return
        st_tree_instance_deco::get(key_assoc_tree_handle(get_tree(), h))
        ->get_related_object();}
    void set_related_object(sc_object * o, sc_process_b * h) {
      st_tree_instance_deco::get(key_assoc_tree_handle(get_tree(), h))
        ->set_related_object(o);}

    dependant_deco get_dependant_deco() const {return m_deco;}
    void set_dependant_deco(dependant_deco  d) {m_deco = d;}
    void * pinapa_decoration;

    const tree get_tree() const {return m_tree;}
    void set_tree(tree  t) {m_tree = t;}

    type_of_type get_type() const {return m_type;}
    void set_type(type_of_type  t) {m_type = t;}

    tree get_old_node() const {return m_old_node;}
    void set_old_node(tree b) {
      m_old_node = b;
      st_tree_deco::get_deco(get_tree())->attach(b);
    }
    static void set_location(tree t, const char * filename, int line);
    bool has_location();
    const char * get_input_filename();
    int get_input_line();
  private:
    const sc_primitive_t m_primitive;
    tree m_tree;
    type_of_type m_type;
    tree m_old_node;

  public:
    dependant_deco m_deco;
  };

  class st_dependant_deco {
  public:

  protected:
    st_dependant_deco() {}
    virtual ~st_dependant_deco() {};
  };

  class st_read_deco : public st_dependant_deco {
  public:

  private:

  };

  class st_write_deco : public st_dependant_deco {
  public:

  };

  class st_func_decl_deco : public st_dependant_deco {
  public:
    tree get_return_value() const {return return_value;}
    void set_return_value(tree r) {return_value = r;}

  private:
    tree return_value;
  };

  class st_tlm_write_deco : public st_dependant_deco {
  public:

  };

  class st_type_deco : public st_dependant_deco {
    //
  };

  class st_data_member_decl_deco : public st_dependant_deco {
    //
  };

  class st_inst_dependant_deco {
  public:

  protected:
    st_inst_dependant_deco() {}
    virtual ~st_inst_dependant_deco() {};
  };

  class st_event_tree_deco : public st_inst_dependant_deco {
  public:
    st_event_tree_deco (sc_event * event) : m_event(event) {}
    sc_event * get_event() const {return m_event;}
  private:
    sc_event * m_event;
  };
  void print_primitive(sc_primitive_t sc_primitive);

  class st_wait_deco : public st_inst_dependant_deco {
  public:
    st_wait_deco(sensitivity s) : m_sensitivity(s) {}
    sensitivity get_sensitivity() const {return m_sensitivity;}
  private:
    sensitivity m_sensitivity;
  };

  typedef st_wait_deco * wait_deco;

}

#endif // PINAPA_TREE_DECORATION_H

Generated by

Back to Pinapa Home Page