Open64 (mfef90, whirl2f, and IR tools)  TAG: version-openad; SVN changeset: 916
Classes | Defines
cxx_base.h File Reference
#include "errors.h"
Include dependency graph for cxx_base.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

class  SLIST_NODE
class  SLIST
class  SLIST_ITER
class  CHAIN_NODE
class  CHAIN
class  CHAIN_ITER
class  CLIST_NODE
class  CLIST
class  CLIST_ITER

Defines

#define DECLARE_SLIST_NODE_CLASS(NAME_NODE)
#define DECLARE_SLIST_CLASS(NAME_LIST, NAME_NODE)
#define DECLARE_SLIST_ITER_CLASS(NAME_ITER, NAME_NODE, NAME_LIST)
#define DECLARE_SLIST_CONST_ITER_CLASS(NAME_ITER, NAME_NODE, NAME_LIST)
#define DECLARE_CHAIN_NODE_CLASS(NAME_NODE)
#define DECLARE_CHAIN_CLASS(NAME_LIST, NAME_NODE)
#define DECLARE_CHAIN_ITER_CLASS(NAME_ITER, NAME_NODE, NAME_LIST)
#define DECLARE_CHAIN_CONST_ITER_CLASS(NAME_ITER, NAME_NODE, NAME_LIST)
#define DECLARE_CLIST_NODE_CLASS(NAME_LIST)
#define DECLARE_CLIST_CLASS(NAME_LIST, NAME_NODE)
#define DECLARE_CLIST_ITER_CLASS(NAME_ITER, NAME_NODE, NAME_LIST)

Define Documentation

#define DECLARE_CHAIN_CLASS (   NAME_LIST,
  NAME_NODE 
)

Definition at line 1010 of file cxx_base.h.

#define DECLARE_CHAIN_CONST_ITER_CLASS (   NAME_ITER,
  NAME_NODE,
  NAME_LIST 
)
Value:
public:                                                                 \
  NAME_ITER(const NAME_LIST *nl)                                        \
              { CHAIN_ITER::Init((NAME_LIST *)nl); }                    \
  const NAME_NODE *First(void)                                          \
              { return (const NAME_NODE *) CHAIN_ITER::First(); }       \
  const NAME_NODE *Last(void)                                           \
              { return (const NAME_NODE *) CHAIN_ITER::Last(); }        \
  const NAME_NODE *Next(void)                                           \
              { return (const NAME_NODE *) CHAIN_ITER::Next(); }        \
  const NAME_NODE *Prev(void)                                           \
              { return (const NAME_NODE *) CHAIN_ITER::Prev(); }        \
  const NAME_NODE *List(void)                                           \
              { return (const NAME_NODE *) CHAIN_ITER::List(); }        \
  const NAME_NODE *Nth(INT n)                                           \
              { return (const NAME_NODE *) CHAIN_ITER::Nth(n); }        \
  const NAME_NODE *Last_Nth(INT n)                                      \
              { return (const NAME_NODE *) CHAIN_ITER::Last_Nth(n); }   \
  const NAME_NODE *Peek_Next(void)                                      \
              { return (const NAME_NODE *) CHAIN_ITER::Peek_Next(); }   \
  const NAME_NODE *Head(void)                                           \
              { return (const NAME_NODE *) CHAIN_ITER::List(); }        \
  const NAME_NODE *Cur(void)                                            \
              { return (const NAME_NODE *) CHAIN_ITER::Cur(); }         \
  BOOL Is_Empty(void) { return CHAIN_ITER::Is_Empty(); }                \
  BOOL Is_Empty_Reverse(void) { return CHAIN_ITER::Is_Empty(); }        \

Definition at line 1070 of file cxx_base.h.

#define DECLARE_CHAIN_ITER_CLASS (   NAME_ITER,
  NAME_NODE,
  NAME_LIST 
)
Value:
public:                                                                 \
  NAME_ITER(NAME_LIST *nl) { CHAIN_ITER::Init(nl); }                    \
  NAME_NODE *First(void) { return (NAME_NODE *) CHAIN_ITER::First(); }  \
  NAME_NODE *Last(void) { return (NAME_NODE *) CHAIN_ITER::Last(); }    \
  NAME_NODE *Next(void) { return (NAME_NODE *) CHAIN_ITER::Next(); }    \
  NAME_NODE *Prev(void) { return (NAME_NODE *) CHAIN_ITER::Prev(); }    \
  NAME_NODE *List(void) { return (NAME_NODE *) CHAIN_ITER::List(); }    \
  NAME_NODE *Nth(INT n) { return (NAME_NODE *) CHAIN_ITER::Nth(n); }    \
  NAME_NODE *Last_Nth(INT n)                                            \
                    { return (NAME_NODE *) CHAIN_ITER::Last_Nth(n); }   \
  NAME_NODE *Peek_Next(void) { return (NAME_NODE *) CHAIN_ITER::Peek_Next(); }\
  NAME_NODE *Head(void) { return (NAME_NODE *) CHAIN_ITER::List(); }    \
  NAME_NODE *Cur(void) { return (NAME_NODE *) CHAIN_ITER::Cur(); }      \
  BOOL Is_Empty(void) { return CHAIN_ITER::Is_Empty(); }                \
  BOOL Is_Empty_Reverse(void) { return CHAIN_ITER::Is_Empty(); }        \

Definition at line 1052 of file cxx_base.h.

#define DECLARE_CHAIN_NODE_CLASS (   NAME_NODE)
Value:
public:                                                                 \
  NAME_NODE *Next(void)                                                 \
                {return (NAME_NODE *)CHAIN_NODE::Next();}               \
  NAME_NODE *Prev(void)                                                 \
                {return (NAME_NODE *)CHAIN_NODE::Prev();}               \
  const NAME_NODE *Next(void) const                                     \
                {return (const NAME_NODE *)CHAIN_NODE::Next();}         \
  const NAME_NODE *Prev(void) const                                     \
                {return (const NAME_NODE *)CHAIN_NODE::Prev();}         \
  NAME_NODE *Insert_Before(NAME_NODE *nd) {                             \
    return (NAME_NODE*) CHAIN_NODE::Insert_Before(nd);                  \
  }                                                                     \
  NAME_NODE *Insert_After(NAME_NODE *nd) {                              \
    return (NAME_NODE*) CHAIN_NODE::Insert_After(nd);                   \
  }                                                                     \
  NAME_NODE *Remove() {                                                 \
    return (NAME_NODE*) CHAIN_NODE::Remove();                           \
  }                                                                     \

Definition at line 983 of file cxx_base.h.

#define DECLARE_CLIST_CLASS (   NAME_LIST,
  NAME_NODE 
)
Value:
public:                                                                 \
  NAME_LIST(NAME_NODE *nd) { CLIST::Init(nd); }                         \
  void Append(NAME_NODE *nd) { CLIST::Append(nd); }                     \
  void Append(NAME_NODE *nd, NAME_NODE *od) {                           \
    CLIST::Append(nd, od);                                              \
  }                                                                     \
  void Prepend(NAME_NODE *nd) { CLIST::Prepend(nd); }                   \
  void Prepend(NAME_NODE *nd, NAME_NODE *od) {                          \
    CLIST::Prepend(nd, od);                                             \
  }                                                                     \
  void Append_List(NAME_LIST *nl) { CLIST::Append_List(nl); }           \
  void Prepend_List(NAME_LIST *nl) { CLIST::Prepend_List(nl); }         \
  NAME_NODE *Remove_Headnode(void) {                                    \
    return (NAME_NODE*)CLIST::Remove_Headnode();                        \
  }                                                                     \
  NAME_NODE *Head(void) { return (NAME_NODE *) CLIST::Head(); }         \
  NAME_NODE *Tail(void) { return (NAME_NODE *) CLIST::Tail(); }         \
  BOOL       Is_Empty(void) const { return CLIST::Is_Empty(); }         \
  INT32      Len(void) const { return CLIST::Len(); }                   \

Definition at line 1448 of file cxx_base.h.

#define DECLARE_CLIST_ITER_CLASS (   NAME_ITER,
  NAME_NODE,
  NAME_LIST 
)
Value:
public:                                                                 \
  NAME_ITER(NAME_NODE *nd) { CLIST_ITER::Init(nd); }                    \
  NAME_ITER(NAME_LIST *nl) { CLIST_ITER::Init(nl); }                    \
  NAME_ITER(void)          { CLIST_ITER::Init();   }                    \
  void Init(NAME_NODE *nd) { CLIST_ITER::Init(nd); }                    \
  void Init(NAME_LIST *nl) { CLIST_ITER::Init(nl); }                    \
  void Set(NAME_NODE *nd) { CLIST_ITER::Set(nd); }                      \
  NAME_NODE *First(void) { return (NAME_NODE *) CLIST_ITER::First(); }  \
  NAME_NODE *Next(void) { return (NAME_NODE *) CLIST_ITER::Next(); }    \
  NAME_NODE *Peek_Next(void){ return (NAME_NODE *) CLIST_ITER::Peek_Next(); }\
  NAME_NODE *Head(void) { return (NAME_NODE *) CLIST_ITER::Head(); }    \
  NAME_NODE *Cur(void) { return (NAME_NODE *) CLIST_ITER::Cur(); }      \
  BOOL       Saw_Head(void) { return CLIST_ITER::Saw_Head(); }          \

Definition at line 1478 of file cxx_base.h.

#define DECLARE_CLIST_NODE_CLASS (   NAME_LIST)
Value:
\
public:                                                               \
  NAME_LIST *Next(void) {return (NAME_LIST *) CLIST_NODE::Next();}    \
  void Insert_After(NAME_LIST *nd) {                                  \
    CLIST_NODE::Insert_After(nd);                                     \
  }                                                                   \
  void Insert_Before(NAME_LIST *nd) {                                 \
    CLIST_NODE::Insert_Before(nd);                                    \
  }                                                                   \
  NAME_NODE* Remove(NAME_LIST *prev) {                                \
    return (NAME_NODE*)CLIST_NODE::Remove(prev);                      \
  }                                                                   \
  void Set_Next(NAME_LIST *nd) {                                      \
    CLIST_NODE::Set_Next(nd);                                         \
  }                                                                   \
  INT32 Len(void)  { return CLIST_NODE::Len(); }                      \

Definition at line 1422 of file cxx_base.h.

#define DECLARE_SLIST_CLASS (   NAME_LIST,
  NAME_NODE 
)
Value:
public:                                                                 \
  typedef NAME_NODE CONTAINER_NODE;                                     \
  NAME_LIST(NAME_NODE *nd) { SLIST::Init(nd); }                         \
  NAME_LIST() : SLIST() {}                                              \
  void Append(NAME_NODE *nd) { SLIST::Append(nd); }                     \
  BOOL Append(NAME_NODE *nd, NAME_NODE *od) {                           \
    return SLIST::Append(nd, od);                                       \
  }                                                                     \
  void Prepend(NAME_NODE *nd) { SLIST::Prepend(nd); }                   \
  BOOL Prepend(NAME_NODE *nd, NAME_NODE *od) {                          \
    return SLIST::Prepend(nd, od);                                      \
  }                                                                     \
  void Append_List(NAME_LIST *nl) { SLIST::Append_List(nl); }           \
  void Prepend_List(NAME_LIST *nl) { SLIST::Prepend_List(nl); }         \
  NAME_NODE *Remove_Headnode(void) {                                    \
    return (NAME_NODE*) SLIST::Remove_Headnode();                       \
  }                                                                     \
  NAME_NODE *Remove(NAME_NODE *prev, NAME_NODE *cur) {                  \
    return (NAME_NODE*) SLIST::Remove(prev, cur);                       \
  }                                                                     \
  NAME_NODE *Head(void) { return (NAME_NODE *) SLIST::Head(); }         \
  const NAME_NODE *Head(void) const                                     \
                { return (const NAME_NODE *) SLIST::Head(); }           \
  NAME_NODE *Tail(void) { return (NAME_NODE *) SLIST::Tail(); }         \
  const NAME_NODE *Tail(void) const                                     \
                { return (const NAME_NODE *) SLIST::Tail(); }           \
  BOOL       Is_Empty(void) const { return SLIST::Is_Empty(); }         \
  INT32      Len(void) const { return SLIST::Len(); }                   \
  INT        Pos(NAME_NODE *od) { return SLIST::Pos(od); }              \

Definition at line 557 of file cxx_base.h.

#define DECLARE_SLIST_CONST_ITER_CLASS (   NAME_ITER,
  NAME_NODE,
  NAME_LIST 
)
Value:
public:                                                                 \
  NAME_ITER(const NAME_NODE *nd) { SLIST_ITER::Init((NAME_NODE*)nd); } \
  NAME_ITER(const NAME_LIST *nl) { SLIST_ITER::Init((NAME_LIST*)nl); } \
  NAME_ITER(void)          { SLIST_ITER::Init();   }                    \
  void Init(NAME_NODE *nd) { SLIST_ITER::Init(nd); }                    \
  void Init(NAME_LIST *nl) { SLIST_ITER::Init(nl); }                    \
  void Set(NAME_NODE *nd) { SLIST_ITER::Set(nd); }                      \
  const NAME_NODE *First(void) { return (NAME_NODE *) SLIST_ITER::First(); } \
  const NAME_NODE *Next(void) { return (NAME_NODE *) SLIST_ITER::Next(); }   \
  const NAME_NODE *Nth(INT n) { return (NAME_NODE *) SLIST_ITER::Nth(n); }   \
  const NAME_NODE *Peek_Next(void) { return (NAME_NODE *) SLIST_ITER::Peek_Next(); }   \
  const NAME_NODE *Head(void) { return (NAME_NODE *) SLIST_ITER::Head(); }   \
  const NAME_NODE *Cur(void) { return (NAME_NODE *) SLIST_ITER::Cur(); }     \
  BOOL Is_Empty(void) { return SLIST_ITER::Is_Empty(); }                     \

Definition at line 612 of file cxx_base.h.

#define DECLARE_SLIST_ITER_CLASS (   NAME_ITER,
  NAME_NODE,
  NAME_LIST 
)
Value:
public:                                                                 \
  NAME_ITER(NAME_NODE *nd) { SLIST_ITER::Init(nd); }                    \
  NAME_ITER(NAME_LIST *nl) { SLIST_ITER::Init(nl); }                    \
  NAME_ITER(void)          { SLIST_ITER::Init();   }                    \
  void Init(NAME_NODE *nd) { SLIST_ITER::Init(nd); }                    \
  void Init(NAME_LIST *nl) { SLIST_ITER::Init(nl); }                    \
  void Set(NAME_NODE *nd) { SLIST_ITER::Set(nd); }                      \
  NAME_NODE *First(void) { return (NAME_NODE *) SLIST_ITER::First(); }  \
  NAME_NODE *Next(void) { return (NAME_NODE *) SLIST_ITER::Next(); }    \
  NAME_NODE *Nth(INT n) { return (NAME_NODE *) SLIST_ITER::Nth(n); }    \
  NAME_NODE *Peek_Next(void) { return (NAME_NODE *) SLIST_ITER::Peek_Next(); }\
  NAME_NODE *Head(void) { return (NAME_NODE *) SLIST_ITER::Head(); }    \
  NAME_NODE *Cur(void) { return (NAME_NODE *) SLIST_ITER::Cur(); }      \
  BOOL Is_Empty(void) { return SLIST_ITER::Is_Empty(); }                \

Definition at line 596 of file cxx_base.h.

#define DECLARE_SLIST_NODE_CLASS (   NAME_NODE)
Value:
\
public:                                                               \
  NAME_NODE *Next(void) {                                             \
    return (NAME_NODE *) SLIST_NODE::Next();                          \
  }                                                                   \
  const NAME_NODE *Next(void) const {                                 \
    return (NAME_NODE *) SLIST_NODE::Next();                          \
  }                                                                   \
  void Insert_After(NAME_NODE *nd) {                                  \
    SLIST_NODE::Insert_After(nd);                                     \
  }                                                                   \
  void Insert_Before(NAME_NODE *nd) {                                 \
    SLIST_NODE::Insert_Before(nd);                                    \
  }                                                                   \
  NAME_NODE *Remove(NAME_NODE *prev) {                                \
    return (NAME_NODE*) SLIST_NODE::Remove(prev);                     \
  }                                                                   \
  void Set_Next(NAME_NODE *nd) {                                      \
    SLIST_NODE::Set_Next(nd);                                         \
  }                                                                   \
  INT32  Len(void) const    { return SLIST_NODE::Len(); }             \
  INT    Pos(NAME_NODE *od) { return SLIST_NODE::Pos(od); }           \

Definition at line 526 of file cxx_base.h.

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines