Return to cord_pos.h CVS log

Up to [local] / OpenXM_contrib / gc / include / private

Annotation of OpenXM_contrib/gc/include/private/cord_pos.h, Revision 1.1.1.1

1.1       maekawa     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:
                     21: # define MAX_DEPTH 48
                     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.             */
                     50: #   define FUNCTION_BUF_SZ 8
                     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: */
                    107: #define CORD_pos_chars_left(p) ((long)((p)[0].cur_end) - (long)((p)[0].cur_pos))
                    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