1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1984. */
   2: /* $Header: node.h,v 2.4 85/08/22 16:05:40 timo Exp $ */
   3: 
   4: /*
   5:  * B editor -- Parse tree and Focus stack.
   6:  */
   7: 
   8: /*
   9:  * Assertion macro.
  10:  *
  11:  * This one differs from the one in #include <assert.h> in that it
  12:  * is usable as an expression operand, e.g. up(ep) || Assert(No).
  13:  * The function asserr() must unconditionally terminate the program.
  14:  * If the accumulated __FILE__ data wastes too much of your data
  15:  * space, omit them and change the code in asserr() that uses them.
  16:  * You better trust your code then, because unless compiled with "-g"
  17:  * it's difficult to dig the line number information from the core dump.
  18:  *
  19:  * There is also a variant called Abort() which is equivalent to Assert(No).
  20:  */
  21: 
  22: #ifdef NDEBUG
  23: #define Abort() abort() /* Always fail */
  24: #define Assert(cond) 0 /* Dummy expression */
  25: #else NDEBUG
  26: #undef __FILE__
  27: #define __FILE__ rcsid
  28: #ifndef __LINE__
  29: #define __LINE__ 0
  30: #endif __LINE__
  31: #define Abort() asserr(__FILE__, __LINE__)
  32: #define Assert(cond) ((cond) || Abort())
  33: #endif NDEBUG
  34: 
  35: typedef struct node *node;
  36: typedef struct path *path;
  37: typedef int markbits;
  38: 
  39: struct node {
  40:     char    type;
  41:     char    _unused;
  42:     intlet  refcnt;
  43:     intlet  len;
  44:     markbits    n_marks;
  45:     intlet  n_width;
  46:     intlet  n_symbol;
  47:     node    n_child[1];
  48: };
  49: 
  50: struct path {
  51:     char    type;
  52:     char    _unused;
  53:     intlet  refcnt;
  54:     intlet  len;
  55:     path    p_parent;
  56:     node    p_tree;
  57:     intlet  p_ichild;
  58:     intlet  p_ycoord;
  59:     intlet  p_xcoord;
  60:     intlet  p_level;
  61:     markbits    p_addmarks;
  62:     markbits    p_delmarks;
  63: };
  64: 
  65: 
  66: #define Nnil ((node) NULL)
  67: 
  68: node newnode();
  69: 
  70: #ifndef NDEBUG
  71: #define symbol(n) (Assert(Type(n)==Nod), (n)->n_symbol)
  72: #define nchildren(n) (Assert(Type(n)==Nod), Length(n))
  73: #define marks(n) (Assert(Type(n)==Nod), (n)->n_marks)
  74: #define child(n, i) \
  75:     (Assert(Type(n)==Nod && (i)>0 && (i)<=Length(n)), (n)->n_child[(i)-1])
  76: #define lastchild(n) \
  77:     (Assert(Type(n)==Nod && Length(n)>0), (n)->n_child[Length(n)-1])
  78: #define firstchild(n) \
  79:     (Assert(Type(n)==Nod && Length(n)>0), (n)->n_child[0])
  80: #else NDEBUG
  81: #define symbol(n) ((n)->n_symbol)
  82: #define nchildren(n) (Length(n))
  83: #define marks(n) ((n)->n_marks)
  84: #define child(n, i) ((n)->n_child[(i)-1])
  85: #define lastchild(n) ((n)->n_child[Length(n)-1])
  86: #define firstchild(n) ((n)->n_child[0])
  87: #endif NDEBUG
  88: 
  89: #define width(n) (Type(n)==Tex ? Length((value)(n)) : (n)->n_width)
  90: #define marked(p, x) (marks(tree(p))&(x))
  91: 
  92: #define Pnil ((path) NULL)
  93: 
  94: path newpath();
  95: 
  96: #define parent(p) ((p)->p_parent)
  97: #define tree(p) ((p)->p_tree)
  98: #define ichild(p) ((p)->p_ichild)
  99: 
 100: #define Ycoord(p) ((p)->p_ycoord)
 101: #define Xcoord(p) ((p)->p_xcoord)
 102: #define Level(p) ((p)->p_level)
 103: 
 104: /* Procedure markpath(); */
 105: /* Procedure unmkpath(); */
 106: /* Procedure replace(); */
 107: bool up();
 108: bool downi();
 109: 
 110: #define down(n) downi(n, 1)
 111: 
 112: bool downrite();
 113: bool left();
 114: bool rite();
 115: /* Procedure top(); */
 116: bool nextnode();
 117: /* Procedure firstleaf(); */
 118: bool nextleaf();
 119: bool prevnode();
 120: /* Procedure lastleaf(); */
 121: bool prevleaf();
 122: bool nextmarked();
 123: bool prevmarked();
 124: 
 125: /*
 126:  * The following are routines for lint, but macros for CC.
 127:  * This way lint can detect wrong arguments passed.
 128:  */
 129: 
 130: #ifdef lint
 131: 
 132: node nodecopy();
 133: noderelease();
 134: nodeuniql();
 135: 
 136: path pathcopy();
 137: pathrelease();
 138: pathuniql();
 139: 
 140: #else
 141: 
 142: #define nodecopy(n) ((node)copy(n))
 143: #define noderelease(n) release(n)
 144: #define nodeuniql(pn) uniql(pn)
 145: 
 146: #define pathcopy(p) ((path)copy(p))
 147: #define pathrelease(p) release(p)
 148: #define pathuniql(pp) uniql(pp)
 149: 
 150: #endif
 151: 
 152: node grab_node();
 153: path grab_path();

Defined struct's

node defined in line 39; used 3 times
path defined in line 50; used 3 times

Defined typedef's

markbits defined in line 37; used 13 times
node defined in line 35; used 179 times

Defined macros

__FILE__ defined in line 27; used 2 times
__LINE__ defined in line 29; used 2 times
marked defined in line 90; used 6 times
marks defined in line 83; used 3 times
nodeuniql defined in line 144; used 5 times
pathuniql defined in line 148; used 2 times
tree defined in line 97; used 157 times

Usage of this include

Last modified: 1985-08-27
Generated: 2016-12-26
Generated by src2html V0.67
page hit count: 1181
Valid CSS Valid XHTML 1.0 Strict