PageRenderTime 48ms CodeModel.GetById 26ms app.highlight 5ms RepoModel.GetById 15ms app.codeStats 0ms

/libs/headers/gc/private/cord_pos.h

http://github.com/nddrylliog/ooc
C++ Header | 118 lines | 47 code | 22 blank | 49 comment | 4 complexity | 56abb788c2eb93713c1ae682c6ec9516 MD5 | raw file
  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
 25struct 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.						*/
 32typedef 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:	*/
 56CORD CORD_pos_to_cord(CORD_pos p);
 57	
 58/* Extract the current index from a position:	*/
 59size_t CORD_pos_to_index(CORD_pos p);
 60	
 61/* Fetch the character located at the given position:	*/
 62char 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:	*/
 66void 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:			*/
 71void 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:			*/
 76void CORD_prev(CORD_pos p);
 77	
 78/* Is the position valid, i.e. inside the cord?		*/
 79int CORD_pos_valid(CORD_pos p);
 80
 81char CORD__pos_fetch(CORD_pos);
 82void CORD__next(CORD_pos);
 83void 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