Return to node.h CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / new / B / src / bed

Annotation of 43BSDTahoe/new/B/src/bed/node.h, revision 1.1.1.1

1.1       root        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();

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.