Return to cord_pos.h CVS log

Up to [parser3project] / parser3 / src / lib / cord / include / private

Annotation of parser3/src/lib/cord/include/private/cord_pos.h, revision 1.5

1.2       paf         1: /* 
                      2:  * Copyright (c) 1993-1994 by Xerox Corporation.  All rights reserved.
                      3:  *
                      4:  * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
                      5:  * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
                      6:  *
                      7:  * Permission is hereby granted to use or copy this program
                      8:  * for any purpose,  provided the above notices are retained on all copies.
                      9:  * Permission to modify the code and to distribute modified code is granted,
                     10:  * provided the above notices are retained, and a notice that the code was
                     11:  * modified is included with the above copyright notice.
                     12:  */
                     13: /* Boehm, May 19, 1994 2:23 pm PDT */
                     14: # ifndef CORD_POSITION_H
                     15: 
                     16: /* The representation of CORD_position.  This is private to the        */
                     17: /* implementation, but the size is known to clients.  Also     */
                     18: /* the implementation of some exported macros relies on it.    */
                     19: /* Don't use anything defined here and not in cord.h.          */
                     20: 
1.4       misha      21: # define MAX_DEPTH 48
1.2       paf        22:        /* The maximum depth of a balanced cord + 1.            */
                     23:        /* We don't let cords get deeper than MAX_DEPTH.        */
                     24: 
                     25: struct CORD_pe {
                     26:     CORD pe_cord;
                     27:     size_t pe_start_pos;
                     28: };
                     29: 
                     30: /* A structure describing an entry on the path from the root   */
                     31: /* to current position.                                                */
                     32: typedef struct CORD_Pos {
                     33:     size_t cur_pos;
                     34:     int path_len;
                     35: #      define CORD_POS_INVALID (0x55555555)
                     36:                /* path_len == INVALID <==> position invalid */
                     37:     const char *cur_leaf;      /* Current leaf, if it is a string.     */
                     38:                                /* If the current leaf is a function,   */
                     39:                                /* then this may point to function_buf  */
                     40:                                /* containing the next few characters.  */
                     41:                                /* Always points to a valid string      */
                     42:                                /* containing the current character     */
                     43:                                /* unless cur_end is 0.                 */
                     44:     size_t cur_start;  /* Start position of cur_leaf   */
                     45:     size_t cur_end;    /* Ending position of cur_leaf  */
                     46:                        /* 0 if cur_leaf is invalid.    */
                     47:     struct CORD_pe path[MAX_DEPTH + 1];
                     48:        /* path[path_len] is the leaf corresponding to cur_pos  */
                     49:        /* path[0].pe_cord is the cord we point to.             */
1.5     ! misha      50: #   define FUNCTION_BUF_SZ 32
1.2       paf        51:     char function_buf[FUNCTION_BUF_SZ];        /* Space for next few chars     */
                     52:                                        /* from function node.          */
                     53: } CORD_pos[1];
                     54: 
                     55: /* Extract the cord from a position:   */
                     56: CORD CORD_pos_to_cord(CORD_pos p);
                     57:        
                     58: /* Extract the current index from a position:  */
                     59: size_t CORD_pos_to_index(CORD_pos p);
                     60:        
                     61: /* Fetch the character located at the given position:  */
                     62: char CORD_pos_fetch(CORD_pos p);
                     63:        
                     64: /* Initialize the position to refer to the give cord and index.        */
                     65: /* Note that this is the most expensive function on positions: */
                     66: void CORD_set_pos(CORD_pos p, CORD x, size_t i);
                     67:        
                     68: /* Advance the position to the next character. */
                     69: /* P must be initialized and valid.            */
                     70: /* Invalidates p if past end:                  */
                     71: void CORD_next(CORD_pos p);
                     72: 
                     73: /* Move the position to the preceding character.       */
                     74: /* P must be initialized and valid.                    */
                     75: /* Invalidates p if past beginning:                    */
                     76: void CORD_prev(CORD_pos p);
                     77:        
                     78: /* Is the position valid, i.e. inside the cord?                */
                     79: int CORD_pos_valid(CORD_pos p);
                     80: 
                     81: char CORD__pos_fetch(CORD_pos);
                     82: void CORD__next(CORD_pos);
                     83: void CORD__prev(CORD_pos);
                     84: 
                     85: #define CORD_pos_fetch(p)      \
                     86:     (((p)[0].cur_end != 0)? \
                     87:        (p)[0].cur_leaf[(p)[0].cur_pos - (p)[0].cur_start] \
                     88:        : CORD__pos_fetch(p))
                     89: 
                     90: #define CORD_next(p)   \
                     91:     (((p)[0].cur_pos + 1 < (p)[0].cur_end)? \
                     92:        (p)[0].cur_pos++ \
                     93:        : (CORD__next(p), 0))
                     94: 
                     95: #define CORD_prev(p)   \
                     96:     (((p)[0].cur_end != 0 && (p)[0].cur_pos > (p)[0].cur_start)? \
                     97:        (p)[0].cur_pos-- \
                     98:        : (CORD__prev(p), 0))
                     99: 
                    100: #define CORD_pos_to_index(p) ((p)[0].cur_pos)
                    101: 
                    102: #define CORD_pos_to_cord(p) ((p)[0].path[0].pe_cord)
                    103: 
                    104: #define CORD_pos_valid(p) ((p)[0].path_len != CORD_POS_INVALID)
                    105: 
                    106: /* Some grubby stuff for performance-critical friends: */
1.5     ! misha     107: #define CORD_pos_chars_left(p) ((long)((p)[0].cur_end) != 0 ? ((long)((p)[0].cur_end) - (long)((p)[0].cur_pos)) : 0 )
1.2       paf       108:        /* Number of characters in cache.  <= 0 ==> none        */
                    109: 
                    110: #define CORD_pos_advance(p,n) ((p)[0].cur_pos += (n) - 1, CORD_next(p))
                    111:        /* Advance position by n characters     */
                    112:        /* 0 < n < CORD_pos_chars_left(p)       */
                    113: 
                    114: #define CORD_pos_cur_char_addr(p) \
                    115:        (p)[0].cur_leaf + ((p)[0].cur_pos - (p)[0].cur_start)
                    116:        /* address of current character in cache.       */
                    117: 
                    118: #endif