stackstash.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
/* $Id$ */
 
#ifndef HEPHAESTUS_STACKSTASH_H
#define HEPHAESTUS_STACKSTASH_H
 
 
#include <stddef.h>
 
 
#ifdef __cplusplus
extern "C" {
#endif
 

typedef void* StackElement;
 

struct StackHandle_
{
  StackElement* element;
  struct StackHandle_* next;
};
typedef struct StackHandle_        StackHandle;
 

struct StackNode_
{
  struct StackNode_* parent;
  unsigned short nelts;
  unsigned short nkids;
  StackHandle* handles;
  /* First elt is always 0. */
  void* p[1];
};
typedef struct StackNode_ StackNode;
 

struct StackCursor_
{
  StackNode* node;
  StackElement* elt;
};
typedef struct StackCursor_ StackCursor;
 

StackHandle* hhh_stackstash_store (const StackElement  *addresses,
                                   int                  n_addresses);
 

StackElement* hhh_stack_element_parent (StackElement* elt);
 

void hhh_Cursor_initRoot(StackCursor* cursor);

void hhh_Cursor_initHandle(StackCursor* cursor, StackHandle* handle);

void hhh_Cursor_parent(StackCursor* cursor);

void hhh_Cursor_child(StackCursor* cursor, int n);

int hhh_Cursor_nchildren(StackCursor* cursor);

void hhh_Cursor_next(StackCursor* cursor);
 
 
/***********************************************************************
 * For internal use.
 */

#define STACK_ELEMENT_BEGIN_P(element) (*((element)-1) == 0)

#define STACK_ELEMENT_NODE(element) \
  ((StackNode*)((char*)((element)-1) - offsetof(StackNode, p)))

#define STACK_ELEMENT_NODEPARENT(element) (STACK_ELEMENT_NODE(element)->parent)

#define STACK_NODE_NTH_ELEMENT(node, n)  ((node)->p[n+1])

#define STACK_NODE_NTH_CHILD(node, n) \
  (*(StackNode**)&((node)->p[n+1+(node)->nelts]))

#define STACK_ELEMENT_NONNULL(elt) ((elt) ? (elt) : (StackElement)1)

#define STACK_NODE_SET_ELEMENT(node, n, elt)  do{ (node)->p[n+1] = STACK_ELEMENT_NONNULL(elt); } while(0)
 
 
 
/***********************************************************************
 * Public interface.
 */
 
 
/*** Operations on StackHandle. */

#define STACK_HANDLE_ELEMENT(handle) ((handle)->element)

#define STACK_HANDLE_ADDR(handle) \
  STACK_ELEMENT_ADDR(STACK_HANDLE_ELEMENT(handle))

#define STACK_HANDLE_PARENT(handle) \
  STACK_ELEMENT_PARENT(STACK_HANDLE_ELEMENT(handle))

#define STACK_HANDLE_IS_ROOT(handle) \
  STACK_ELEMENT_IS_ROOT(STACK_HANDLE_ELEMENT(handle))
 
 
 
/*** Operations on StackElement. */

#define STACK_ELEMENT_ADDR(element) (*(element))

#define STACK_ELEMENT_PARENT(element) hhh_stack_element_parent(element)

#define STACK_ELEMENT_IS_ROOT(element)       (*(element) == 0)
 
 
/*** Operations on StackCursor. */
 

#define STACK_CURSOR_ELEMENT(cursor) ((cursor).elt)

#define STACK_CURSOR_ELEMENT_ADDR(cursor) STACK_ELEMENT_ADDR(STACK_CURSOR_ELEMENT(cursor))

#define STACK_CURSOR_INIT_ROOT(cursor) hhh_Cursor_initRoot(&cursor)

#define STACK_CURSOR_INIT_HANDLE(cursor, handle) hhh_Cursor_initHandle(&cursor, handle)

#define STACK_CURSOR_IS_ROOT(cursor) STACK_ELEMENT_IS_ROOT(STACK_CURSOR_ELEMENT(cursor))

#define STACK_CURSOR_PARENT(cursor) hhh_Cursor_parent(&cursor)

#define STACK_CURSOR_NCHILDREN(cursor) hhh_Cursor_nchildren(&cursor)

#define STACK_CURSOR_CHILD(cursor, n) hhh_Cursor_child(&cursor, n)

#define STACK_CURSOR_NEXT(cursor) hhh_Cursor_next(&cursor)
 
 
#ifdef __cplusplus
} // extern "C"
#endif
 
 
#endif // not HEPHAESTUS_STACKSTASH_H