abstract_handle.h

#ifndef abstract_handle_INCLUDED
#define abstract_handle_INCLUDED

#include <string>
#include <utility>
#include <limits.h>
#include <map>
#include "rosedll.h"

#ifdef _MSC_VER
// DQ (11/26/2009): Required for definition of PATH_MAX in MSVC.
#include "rose_msvc.h"
#endif

// DQ (4/17/2016): This appears to be needed for ROSE to emulate Clang
// in compiling ROSE files in tests/nonsmoke/functional/CompileTests/RoseExample_tests.
#ifdef __clang__
// Find value for PATH_MAX
// Pei-hung (06/22/2016): OSX has limits.h in /usr/include
#if defined(__APPLE__) && defined(__MACH__)
#include<limits.h>
#else
#include<linux/limits.h>
#endif
#endif

namespace AbstractHandle{

  struct source_position
  {
    size_t line;
    size_t column;
  };

  struct source_position_pair
  {
    source_position first;
    source_position second;
  };

  std::string toString(const source_position &);
  std::string toString(const source_position_pair &);
  bool isEqual(const source_position &pos1, const source_position &pos2);
  bool isEqual(const source_position_pair &pair1, const source_position_pair &pair2);
   
  void fromString(source_position&, const std::string& input);
  void fromString(source_position_pair&, const std::string& input);

 //----------specifiers------------------------------------
  typedef  enum {e_name, e_position, e_numbering, e_int_label, e_str_label} 
    specifier_type_t;

  typedef union u_specifier_value
     {
       char str_v[PATH_MAX+256];
       size_t int_v; 
       source_position_pair positions;
     } specifier_value_t;

  class specifier
  {
  public:
    specifier(){};
    specifier (specifier_type_t t, specifier_value_t v):type(t),value(v){}
    specifier_type_t get_type(){return type;}
    specifier_value_t  get_value(){return value;}
    void set_type(specifier_type_t stype) { type=stype;}
    void set_value(specifier_value_t svalue) {value=svalue;}
    std::string toString();
  private:  
     specifier_type_t type; 
     specifier_value_t value ;
  };

  // Parse a string into a specifier 
  void fromString(specifier&, const std::string& input);

 //----------------Abstract AST/IR node---------------
 class abstract_node
 {
  public: 
  virtual ~abstract_node(){}

  virtual std::string getConstructTypeName() const;

  virtual bool hasSourcePos() const;

  virtual bool hasName() const;

  virtual std::string getName() const;

  virtual abstract_node* getFileNode() const;

  virtual abstract_node* getParent() const;

#ifdef _MSC_VER
// DQ (11/27/2009): MSVC does not appear to support covariant types, but no message is required.
 #pragma message ("WARNING: MSVC does not handle covariant return types properly.")
#else
  virtual void * getNode() const {return NULL;};
#endif

  virtual abstract_node* findNode(std::string handle_str) const;  

  virtual abstract_node* findNode(std::string construct_type_str, specifier mspecifier) const;  

  virtual std::string getFileName() const;

  virtual source_position_pair getSourcePos() const;
  virtual source_position getStartPos() const;
  virtual source_position getEndPos() const;

  virtual std::string toString() const;

  virtual size_t getIntLabel() const;
  virtual std::string getStringLabel() const;

  virtual size_t getNumbering( const abstract_node*  another_node) const;

  virtual bool operator == (const abstract_node & x) const=0;
 }; // end class abstract_node

  //---------------- An abstract handle --------------------------
  class ROSE_DLL_API abstract_handle 
  {
  public:

    abstract_handle();
    abstract_handle(abstract_node* node);

    abstract_handle(abstract_node* node, specifier_type_t stype, \
                   specifier_value_t svalue, abstract_handle* p_handle=NULL);

     abstract_handle(abstract_node* node, specifier_type_t stype, \
               abstract_handle* p_handle=NULL);

    abstract_handle(abstract_handle* phandle, const std::string& handle_string);
    
    virtual ~abstract_handle() { if (m_specifier !=NULL) delete m_specifier;}

    virtual std::string get_construct_type_name();

    virtual std::string toString();

    virtual bool fromString(abstract_handle* ancester_handle, const std::string &handle_str_multiple);

    virtual std::string toStringSelf();

    virtual void fromStringSelf(abstract_handle* p_handle, const std::string& handle_str_item);

   virtual abstract_node* getNode() const {return m_node;}
   specifier* get_specifier(){return m_specifier;}
  
  abstract_handle* get_parent_handle(){return parent_handle; }
  void set_parent_handle(abstract_handle* parent){ parent_handle= parent;}

  //Any other way to implement this??
  bool operator == (const abstract_handle& x) const
    { return m_node == x.getNode();}

  private: 
    void init();
    abstract_handle * parent_handle;
    // shared handles cannot have a single next handle
    // abstract_handle * next_handle; // expose them or not?
    
    abstract_node* m_node; 
    specifier * m_specifier;
    abstract_handle (const abstract_handle &); // disallow copy
    abstract_handle & operator = (const abstract_handle &);

  };

 extern std::map<abstract_node*, abstract_handle*> handle_map; 

}// end namespace 

#endif