procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

cpphash.h (struct cpp_buff): Make unsigned.

Browse source 
* cpphash.h (struct cpp_buff): Make unsigned.
	(_cpp_get_buff): Take length of size_t.
	(_cpp_unaligned_alloc): New.
	(BUFF_ROOM, BUFF_FRONT, BUFF_LIMIT): New.
	(struct cpp_reader): Remove ident_pool.  Add u_buff.
	* cppinit.c (cpp_create_reader): Initialize u_buff, not ident_pool.
	(cpp_destroy): Destroy u_buff, not ident_pool.
	* cpplex.c (parse_number, parse_string, save_comment,
	cpp_token_as_text): Update to use the unaligned buffer.
	(new_buff): Make unsigned.
	(_cpp_unaligned_alloc): New.
	* cpplib.c (glue_header_name): Update to use the unaligned buffer.
	* cppmacro.c (new_number_token, builtin_macro, stringify_arg):
	Similarly.
	(collect_args): Make unsigned.

From-SVN: r45858
This commit is contained in:
Neil Booth 2001-09-28 09:40:22 +00:00 • committed by Neil Booth
parent 0c0d83a1b4
commit ece54d544d
6 changed files with 129 additions and 75 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
gcc/ChangeLog
View file

@ -1,3 +1,21 @@
2001-09-28 Neil Booth <neil@daikokuya.demon.co.uk>
* cpphash.h (struct cpp_buff): Make unsigned.
(_cpp_get_buff): Take length of size_t.
(_cpp_unaligned_alloc): New.
(BUFF_ROOM, BUFF_FRONT, BUFF_LIMIT): New.
(struct cpp_reader): Remove ident_pool. Add u_buff.
* cppinit.c (cpp_create_reader): Initialize u_buff, not ident_pool.
(cpp_destroy): Destroy u_buff, not ident_pool.
* cpplex.c (parse_number, parse_string, save_comment,
cpp_token_as_text): Update to use the unaligned buffer.
(new_buff): Make unsigned.
(_cpp_unaligned_alloc): New.
* cpplib.c (glue_header_name): Update to use the unaligned buffer.
* cppmacro.c (new_number_token, builtin_macro, stringify_arg):
Similarly.
(collect_args): Make unsigned.
2001-09-27 Zack Weinberg <zack@codesourcery.com>
* cpplex.c (cpp_output_token): Use a putc loop for

15
gcc/cpphash.h
View file

@ -77,14 +77,18 @@ typedef struct _cpp_buff _cpp_buff;
struct _cpp_buff
{
struct _cpp_buff *next;
char *base, *cur, *limit;
unsigned char *base, *cur, *limit;
};
extern _cpp_buff *_cpp_get_buff PARAMS ((cpp_reader *, unsigned int));
extern _cpp_buff *_cpp_get_buff PARAMS ((cpp_reader *, size_t));
extern void _cpp_release_buff PARAMS ((cpp_reader *, _cpp_buff *));
extern _cpp_buff *_cpp_extend_buff PARAMS ((cpp_reader *, _cpp_buff *,
unsigned int));
size_t));
extern void _cpp_free_buff PARAMS ((_cpp_buff *));
extern unsigned char *_cpp_unaligned_alloc PARAMS ((cpp_reader *, size_t));
#define BUFF_ROOM(BUFF) ((BUFF)->limit - (BUFF)->cur)
#define BUFF_FRONT(BUFF) ((BUFF)->cur)
#define BUFF_LIMIT(BUFF) ((BUFF)->limit)
/* List of directories to look for include files in. */
struct search_path
@ -267,12 +271,11 @@ struct cpp_reader
unsigned int directive_line;
/* Memory pools. */
cpp_pool ident_pool; /* For all identifiers, and permanent
numbers and strings. */
cpp_pool macro_pool; /* For macro definitions. Permanent. */
/* Memory buffers. */
_cpp_buff *free_buffs;
_cpp_buff *u_buff; /* Unaligned permanent storage. */
_cpp_buff *free_buffs; /* Free buffer chain. */
/* Context stack. */
struct cpp_context base_context;

6
gcc/cppinit.c
View file

@ -527,8 +527,8 @@ cpp_create_reader (table, lang)
pfile->base_context.macro = 0;
pfile->base_context.prev = pfile->base_context.next = 0;
/* Identifier pool initially 8K. Unaligned, permanent pool. */
_cpp_init_pool (&pfile->ident_pool, 8 * 1024, 1, 0);
/* Unaligned storage. */
pfile->u_buff = _cpp_get_buff (pfile, 0);
/* Macro pool initially 8K. Aligned, permanent pool. */
_cpp_init_pool (&pfile->macro_pool, 8 * 1024, 0, 0);
@ -585,8 +585,8 @@ cpp_destroy (pfile)
_cpp_destroy_hashtable (pfile);
_cpp_cleanup_includes (pfile);
_cpp_free_pool (&pfile->ident_pool);
_cpp_free_pool (&pfile->macro_pool);
_cpp_free_buff (pfile->u_buff);
_cpp_free_buff (pfile->free_buffs);
for (run = &pfile->base_run; run; run = runn)

75
gcc/cpplex.c
View file

@ -599,17 +599,20 @@ parse_number (pfile, number, c, leading_period)
int leading_period;
{
cpp_buffer *buffer = pfile->buffer;
cpp_pool *pool = &pfile->ident_pool;
unsigned char *dest, *limit;
dest = POOL_FRONT (pool);
limit = POOL_LIMIT (pool);
dest = BUFF_FRONT (pfile->u_buff);
limit = BUFF_LIMIT (pfile->u_buff);
/* Place a leading period. */
if (leading_period)
{
if (dest >= limit)
limit = _cpp_next_chunk (pool, 0, &dest);
if (dest == limit)
{
pfile->u_buff = _cpp_extend_buff (pfile, pfile->u_buff, 1);
dest = BUFF_FRONT (pfile->u_buff);
limit = BUFF_LIMIT (pfile->u_buff);
}
*dest++ = '.';
}
@ -618,8 +621,13 @@ parse_number (pfile, number, c, leading_period)
do
{
/* Need room for terminating null. */
if (dest + 1 >= limit)
limit = _cpp_next_chunk (pool, 0, &dest);
if ((size_t) (limit - dest) < 2)
{
size_t len_so_far = dest - BUFF_FRONT (pfile->u_buff);
pfile->u_buff = _cpp_extend_buff (pfile, pfile->u_buff, 2);
dest = BUFF_FRONT (pfile->u_buff) + len_so_far;
limit = BUFF_LIMIT (pfile->u_buff);
}
*dest++ = c;
c = EOF;
@ -643,9 +651,9 @@ parse_number (pfile, number, c, leading_period)
/* Null-terminate the number. */
*dest = '\0';
number->text = POOL_FRONT (pool);
number->text = BUFF_FRONT (pfile->u_buff);
number->len = dest - number->text;
POOL_COMMIT (pool, number->len + 1);
BUFF_FRONT (pfile->u_buff) = dest + 1;
}
/* Subroutine of parse_string. Emits error for unterminated strings. */
@ -676,7 +684,7 @@ unescaped_terminator_p (pfile, dest)
if (pfile->state.angled_headers)
return 1;
start = POOL_FRONT (&pfile->ident_pool);
start = BUFF_FRONT (pfile->u_buff);
/* An odd number of consecutive backslashes represents an escaped
terminator. */
@ -699,13 +707,12 @@ parse_string (pfile, token, terminator)
cppchar_t terminator;
{
cpp_buffer *buffer = pfile->buffer;
cpp_pool *pool = &pfile->ident_pool;
unsigned char *dest, *limit;
cppchar_t c;
bool warned_nulls = false, warned_multi = false;
dest = POOL_FRONT (pool);
limit = POOL_LIMIT (pool);
dest = BUFF_FRONT (pfile->u_buff);
limit = BUFF_LIMIT (pfile->u_buff);
for (;;)
{
@ -716,8 +723,13 @@ parse_string (pfile, token, terminator)
have_char:
/* We need space for the terminating NUL. */
if (dest >= limit)
limit = _cpp_next_chunk (pool, 0, &dest);
if ((size_t) (limit - dest) < 1)
{
size_t len_so_far = dest - BUFF_FRONT (pfile->u_buff);
pfile->u_buff = _cpp_extend_buff (pfile, pfile->u_buff, 2);
dest = BUFF_FRONT (pfile->u_buff) + len_so_far;
limit = BUFF_LIMIT (pfile->u_buff);
}
if (c == EOF)
{
@ -781,9 +793,9 @@ parse_string (pfile, token, terminator)
buffer->read_ahead = c;
*dest = '\0';
token->val.str.text = POOL_FRONT (pool);
token->val.str.len = dest - token->val.str.text;
POOL_COMMIT (pool, token->val.str.len + 1);
token->val.str.text = BUFF_FRONT (pfile->u_buff);
token->val.str.len = dest - BUFF_FRONT (pfile->u_buff);
BUFF_FRONT (pfile->u_buff) = dest + 1;
}
/* The stored comment includes the comment start and any terminator. */
@ -801,7 +813,7 @@ save_comment (pfile, token, from)
line, which we don't want to save in the comment. */
if (pfile->buffer->read_ahead != EOF)
len--;
buffer = _cpp_pool_alloc (&pfile->ident_pool, len);
buffer = _cpp_unaligned_alloc (pfile, len);
token->type = CPP_COMMENT;
token->val.str.len = len;
@ -1485,7 +1497,7 @@ cpp_token_as_text (pfile, token)
const cpp_token *token;
{
unsigned int len = cpp_token_len (token);
unsigned char *start = _cpp_pool_alloc (&pfile->ident_pool, len), *end;
unsigned char *start = _cpp_unaligned_alloc (pfile, len), *end;
end = cpp_spell_token (pfile, token, start);
end[0] = '\0';
@ -2043,7 +2055,7 @@ new_buff (len)
unsigned int len;
{
_cpp_buff *result;
char *base;
unsigned char *base;
if (len < MIN_BUFF_SIZE)
len = MIN_BUFF_SIZE;
@ -2130,6 +2142,27 @@ _cpp_free_buff (buff)
}
}
/* Allocate permanent, unaligned storage of length LEN. */
unsigned char *
_cpp_unaligned_alloc (pfile, len)
cpp_reader *pfile;
size_t len;
{
_cpp_buff *buff = pfile->u_buff;
unsigned char *result = buff->cur;
if (len > (size_t) (buff->limit - result))
{
buff = _cpp_get_buff (pfile, len);
buff->next = pfile->u_buff;
pfile->u_buff = buff;
result = buff->cur;
}
buff->cur = result + len;
return result;
}
static int
chunk_suitable (chunk, size)
cpp_chunk *chunk;

33
gcc/cpplib.c
View file

@ -493,13 +493,13 @@ glue_header_name (pfile)
{
cpp_token *header = NULL;
const cpp_token *token;
unsigned char *buffer, *token_mem;
size_t len, total_len = 0, capacity = 1024;
unsigned char *dest;
size_t len;
/* To avoid lexed tokens overwriting our glued name, we can only
allocate from the string pool once we've lexed everything. */
buffer = (unsigned char *) xmalloc (capacity);
dest = BUFF_FRONT (pfile->u_buff);
for (;;)
{
token = cpp_get_token (pfile);
@ -507,35 +507,34 @@ glue_header_name (pfile)
if (token->type == CPP_GREATER || token->type == CPP_EOF)
break;
len = cpp_token_len (token);
if (total_len + len > capacity)
/* + 1 for terminating NUL. */
len = cpp_token_len (token) + 1;
if ((size_t) (BUFF_LIMIT (pfile->u_buff) - dest) < len)
{
capacity = (capacity + len) * 2;
buffer = (unsigned char *) xrealloc (buffer, capacity);
size_t len_so_far = dest - BUFF_FRONT (pfile->u_buff);
pfile->u_buff = _cpp_extend_buff (pfile, pfile->u_buff, len);
dest = BUFF_FRONT (pfile->u_buff) + len_so_far;
}
if (token->flags & PREV_WHITE)
buffer[total_len++] = ' ';
*dest++ = ' ';
total_len = cpp_spell_token (pfile, token, &buffer[total_len]) - buffer;
dest = cpp_spell_token (pfile, token, dest);
}
if (token->type == CPP_EOF)
cpp_error (pfile, "missing terminating > character");
else
{
token_mem = _cpp_pool_alloc (&pfile->ident_pool, total_len + 1);
memcpy (token_mem, buffer, total_len);
token_mem[total_len] = '\0';
header = _cpp_temp_token (pfile);
header->type = CPP_HEADER_NAME;
header->flags &= ~PREV_WHITE;
header->val.str.len = total_len;
header->val.str.text = token_mem;
header->flags = 0;
header->val.str.len = dest - BUFF_FRONT (pfile->u_buff);
header->val.str.text = BUFF_FRONT (pfile->u_buff);
*dest++ = '\0';
BUFF_FRONT (pfile->u_buff) = dest;
}
free ((PTR) buffer);
return header;
}

57
gcc/cppmacro.c
View file

@ -116,7 +116,7 @@ new_number_token (pfile, number)
int number;
{
cpp_token *token = _cpp_temp_token (pfile);
unsigned char *buf = _cpp_pool_alloc (&pfile->ident_pool, 20);
unsigned char *buf = _cpp_unaligned_alloc (pfile, 20);
sprintf ((char *) buf, "%d", number);
token->type = CPP_NUMBER;
@ -158,7 +158,7 @@ builtin_macro (pfile, node)
name = map->to_file;
len = strlen (name);
buf = _cpp_pool_alloc (&pfile->ident_pool, len * 4 + 1);
buf = _cpp_unaligned_alloc (pfile, len * 4 + 1);
len = quote_string (buf, (const unsigned char *) name, len) - buf;
return new_string_token (pfile, buf, len);
@ -196,7 +196,7 @@ builtin_macro (pfile, node)
struct tm *tb = localtime (&tt);
pfile->date.val.str.text =
_cpp_pool_alloc (&pfile->ident_pool, sizeof ("Oct 11 1347"));
_cpp_unaligned_alloc (pfile, sizeof ("Oct 11 1347"));
pfile->date.val.str.len = sizeof ("Oct 11 1347") - 1;
pfile->date.type = CPP_STRING;
pfile->date.flags = 0;
@ -204,7 +204,7 @@ builtin_macro (pfile, node)
monthnames[tb->tm_mon], tb->tm_mday, tb->tm_year + 1900);
pfile->time.val.str.text =
_cpp_pool_alloc (&pfile->ident_pool, sizeof ("12:34:56"));
_cpp_unaligned_alloc (pfile, sizeof ("12:34:56"));
pfile->time.val.str.len = sizeof ("12:34:56") - 1;
pfile->time.type = CPP_STRING;
pfile->time.flags = 0;
@ -255,17 +255,15 @@ stringify_arg (pfile, arg)
cpp_reader *pfile;
macro_arg *arg;
{
cpp_pool *pool = &pfile->ident_pool;
unsigned char *start = POOL_FRONT (pool);
unsigned int i, escape_it, total_len = 0, backslash_count = 0;
unsigned char *dest = BUFF_FRONT (pfile->u_buff);
unsigned int i, escape_it, backslash_count = 0;
const cpp_token *source = NULL;
size_t len;
/* Loop, reading in the argument's tokens. */
for (i = 0; i < arg->count; i++)
{
unsigned char *dest;
const cpp_token *token = arg->first[i];
unsigned int len;
if (token->type == CPP_PADDING)
{
@ -277,21 +275,22 @@ stringify_arg (pfile, arg)
escape_it = (token->type == CPP_STRING || token->type == CPP_WSTRING
|| token->type == CPP_CHAR || token->type == CPP_WCHAR);
/* Room for each char being written in octal, initial space and
final NUL. */
len = cpp_token_len (token);
if (escape_it)
/* Worst case is each char is octal. */
len *= 4;
len += 2; /* Room for initial space and final NUL. */
len += 2;
dest = &start[total_len];
if (dest + len > POOL_LIMIT (pool))
if ((size_t) (BUFF_LIMIT (pfile->u_buff) - dest) < len)
{
_cpp_next_chunk (pool, len, (unsigned char **) &start);
dest = &start[total_len];
size_t len_so_far = dest - BUFF_FRONT (pfile->u_buff);
pfile->u_buff = _cpp_extend_buff (pfile, pfile->u_buff, len);
dest = BUFF_FRONT (pfile->u_buff) + len_so_far;
}
/* Leading white space? */
if (total_len)
if (dest != BUFF_FRONT (pfile->u_buff))
{
if (source == NULL)
source = token;
@ -302,15 +301,14 @@ stringify_arg (pfile, arg)
if (escape_it)
{
unsigned char *buf = (unsigned char *) xmalloc (len);
_cpp_buff *buff = _cpp_get_buff (pfile, len);
unsigned char *buf = BUFF_FRONT (buff);
len = cpp_spell_token (pfile, token, buf) - buf;
dest = quote_string (dest, buf, len);
free (buf);
_cpp_release_buff (pfile, buff);
}
else
dest = cpp_spell_token (pfile, token, dest);
total_len = dest - start;
if (token->type == CPP_OTHER && token->val.c == '\\')
backslash_count++;
@ -322,12 +320,13 @@ stringify_arg (pfile, arg)
if (backslash_count & 1)
{
cpp_warning (pfile, "invalid string literal, ignoring final '\\'");
total_len--;
dest--;
}
/* Commit the memory, including NUL, and return the token. */
POOL_COMMIT (pool, total_len + 1);
return new_string_token (pfile, start, total_len);
len = dest - BUFF_FRONT (pfile->u_buff);
BUFF_FRONT (pfile->u_buff) = dest + 1;
return new_string_token (pfile, dest - len, len);
}
/* Try to paste two tokens. On success, return non-zero. In any
@ -447,7 +446,7 @@ collect_args (pfile, node)
base_buff = buff;
args = (macro_arg *) buff->base;
memset (args, 0, argc * sizeof (macro_arg));
buff->cur = (char *) &args[argc];
buff->cur = (unsigned char *) &args[argc];
arg = args, argc = 0;
/* Collect the tokens making up each argument. We don't yet know
@ -464,7 +463,7 @@ collect_args (pfile, node)
for (;;)
{
/* Require space for 2 new tokens (including a CPP_EOF). */
if ((char *) &arg->first[ntokens + 2] > buff->limit)
if ((unsigned char *) &arg->first[ntokens + 2] > buff->limit)
{
buff = _cpp_extend_buff (pfile, buff,
1000 * sizeof (cpp_token *));
@ -512,7 +511,7 @@ collect_args (pfile, node)
overwrite the final legitimate argument, before failing. */
if (argc <= macro->paramc)
{
buff->cur = (char *) &arg->first[ntokens + 1];
buff->cur = (unsigned char *) &arg->first[ntokens + 1];
if (argc != macro->paramc)
arg++;
}
@ -538,10 +537,12 @@ collect_args (pfile, node)
step_back = true;
}
else
/* We still need the CPP_EOF to end directives, and to end
pre-expansion of a macro argument. */
step_back = (pfile->context->prev || pfile->state.in_directive);
/* We still need the CPP_EOF to end directives, and to end
pre-expansion of a macro argument. Step back is not
unconditional, since we don't want to return a CPP_EOF to our
callers at the end of an -include-d file. */
if (step_back)
_cpp_backup_tokens (pfile, 1);
cpp_error (pfile, "unterminated argument list invoking macro \"%s\"",