X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gas%2Finput-scrub.c;h=14c00149b89fe33f7bfa97504a371c689bcec4e2;hb=0394eed15c5bf24943850f356785152c3d65ab94;hp=2657b8ac5976808346adab915decceec0026538e;hpb=2da5c03714e1f97bb83d05114e97dcf92eb17b64;p=deliverable%2Fbinutils-gdb.git diff --git a/gas/input-scrub.c b/gas/input-scrub.c index 2657b8ac59..14c00149b8 100644 --- a/gas/input-scrub.c +++ b/gas/input-scrub.c @@ -1,13 +1,11 @@ /* input_scrub.c - Break up input buffers into whole numbers of lines. - Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, - 2000, 2001, 2003 - Free Software Foundation, Inc. + Copyright (C) 1987-2019 Free Software Foundation, Inc. This file is part of GAS, the GNU Assembler. GAS is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2, or (at your option) + the Free Software Foundation; either version 3, or (at your option) any later version. GAS is distributed in the hope that it will be useful, @@ -17,11 +15,11 @@ You should have received a copy of the GNU General Public License along with GAS; see the file COPYING. If not, write to the Free - Software Foundation, 59 Temple Place - Suite 330, Boston, MA - 02111-1307, USA. */ + Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA + 02110-1301, USA. */ -#include /* Need this to make errno declaration right */ #include "as.h" +#include "filenames.h" #include "input-file.h" #include "sb.h" #include "listing.h" @@ -57,21 +55,26 @@ #define BEFORE_SIZE (1) #define AFTER_SIZE (1) +#ifndef TC_EOL_IN_INSN +#define TC_EOL_IN_INSN(P) 0 +#endif + static char *buffer_start; /*->1st char of full buffer area. */ static char *partial_where; /*->after last full line in buffer. */ -static int partial_size; /* >=0. Number of chars in partial line in buffer. */ +static size_t partial_size; /* >=0. Number of chars in partial line in buffer. */ /* Because we need AFTER_STRING just after last full line, it clobbers 1st part of partial line. So we preserve 1st part of partial line here. */ static char save_source[AFTER_SIZE]; -/* What is the largest size buffer that input_file_give_next_buffer() - could return to us? */ -static unsigned int buffer_length; +/* The size of the input buffer we concatenate + input_file_give_next_buffer chunks into. Excludes the BEFORE and + AFTER counts. */ +static size_t buffer_length; /* The index into an sb structure we are reading from. -1 if none. */ -static int sb_index = -1; +static size_t sb_index = -1; /* If we are reading from an sb structure, this is it. */ static sb from_sb; @@ -93,27 +96,26 @@ int macro_nest; source line numbers. Whenever we open a file we must fill in physical_input_file. So if it is NULL we have not opened any files yet. */ -static char *physical_input_file; -static char *logical_input_file; +static const char *physical_input_file; +static const char *logical_input_file; -typedef unsigned int line_numberT; /* 1-origin line number in a source file. */ +/* 1-origin line number in a source file. */ /* A line ends in '\n' or eof. */ - -static line_numberT physical_input_line; +static unsigned int physical_input_line; static int logical_input_line; /* Struct used to save the state of the input handler during include files */ struct input_save { char * buffer_start; char * partial_where; - int partial_size; + size_t partial_size; char save_source[AFTER_SIZE]; - unsigned int buffer_length; - char * physical_input_file; - char * logical_input_file; - line_numberT physical_input_line; + size_t buffer_length; + const char * physical_input_file; + const char * logical_input_file; + unsigned int physical_input_line; int logical_input_line; - int sb_index; + size_t sb_index; sb from_sb; int from_sb_is_expansion; /* Should we do a conditional check? */ struct input_save * next_saved_file; /* Chain of input_saves. */ @@ -123,13 +125,26 @@ struct input_save { static struct input_save *input_scrub_push (char *saved_position); static char *input_scrub_pop (struct input_save *arg); -static void as_1_char (unsigned int c, FILE * stream); /* Saved information about the file that .include'd this one. When we hit EOF, we automatically pop to that file. */ static struct input_save *next_saved_file; +/* Initialize input buffering. */ + +static void +input_scrub_reinit (void) +{ + input_file_begin (); /* Reinitialize! */ + logical_input_line = -1; + logical_input_file = NULL; + + buffer_length = input_file_buffer_size () * 2; + buffer_start = XNEWVEC (char, BEFORE_SIZE + AFTER_SIZE + 1 + buffer_length); + memcpy (buffer_start, BEFORE_STRING, (int) BEFORE_SIZE); +} + /* Push the state of input reading and scrubbing so that we can #include. The return value is a 'void *' (fudged for old compilers) to a save area, which can be restored by passing it to input_scrub_pop(). */ @@ -137,9 +152,9 @@ static struct input_save *next_saved_file; static struct input_save * input_scrub_push (char *saved_position) { - register struct input_save *saved; + struct input_save *saved; - saved = (struct input_save *) xmalloc (sizeof *saved); + saved = XNEW (struct input_save); saved->saved_position = saved_position; saved->buffer_start = buffer_start; @@ -157,14 +172,9 @@ input_scrub_push (char *saved_position) saved->next_saved_file = next_saved_file; saved->input_file_save = input_file_push (); - input_file_begin (); /* Reinitialize! */ - logical_input_line = -1; - logical_input_file = (char *) NULL; - buffer_length = input_file_buffer_size (); sb_index = -1; - buffer_start = xmalloc ((BEFORE_SIZE + buffer_length + buffer_length + AFTER_SIZE)); - memcpy (buffer_start, BEFORE_STRING, (int) BEFORE_SIZE); + input_scrub_reinit (); return saved; } @@ -203,18 +213,9 @@ input_scrub_begin (void) know (strlen (AFTER_STRING) == AFTER_SIZE || (AFTER_STRING[0] == '\0' && AFTER_SIZE == 1)); - input_file_begin (); - - buffer_length = input_file_buffer_size (); - - buffer_start = xmalloc ((BEFORE_SIZE + buffer_length + buffer_length + AFTER_SIZE)); - memcpy (buffer_start, BEFORE_STRING, (int) BEFORE_SIZE); - - /* Line number things. */ - logical_input_line = -1; - logical_input_file = (char *) NULL; physical_input_file = NULL; /* No file read yet. */ next_saved_file = NULL; /* At EOF, don't pop to any other file */ + input_scrub_reinit (); do_scrub_begin (flag_m68k_mri); } @@ -233,7 +234,7 @@ input_scrub_end (void) Return start of caller's part of buffer. */ char * -input_scrub_new_file (char *filename) +input_scrub_new_file (const char *filename) { input_file_open (filename, !flag_no_comments); physical_input_file = filename[0] ? filename : _("{standard input}"); @@ -248,7 +249,7 @@ input_scrub_new_file (char *filename) input_scrub_new_file. */ char * -input_scrub_include_file (char *filename, char *position) +input_scrub_include_file (const char *filename, char *position) { next_saved_file = input_scrub_push (position); return input_scrub_new_file (filename); @@ -260,6 +261,8 @@ input_scrub_include_file (char *filename, char *position) void input_scrub_include_sb (sb *from, char *position, int is_expansion) { + int newline; + if (macro_nest > max_macro_nest) as_fatal (_("macros nested too deeply")); ++macro_nest; @@ -273,14 +276,21 @@ input_scrub_include_sb (sb *from, char *position, int is_expansion) next_saved_file = input_scrub_push (position); - sb_new (&from_sb); + /* Allocate sufficient space: from->len + optional newline. */ + newline = from->len >= 1 && from->ptr[0] != '\n'; + sb_build (&from_sb, from->len + newline); from_sb_is_expansion = is_expansion; - if (from->len >= 1 && from->ptr[0] != '\n') + if (newline) { /* Add the sentinel required by read.c. */ sb_add_char (&from_sb, '\n'); } - sb_add_sb (&from_sb, from); + sb_scrub_and_add_sb (&from_sb, from); + + /* Make sure the parser looks at defined contents when it scans for + e.g. end-of-line at the end of a macro. */ + sb_terminate (&from_sb); + sb_index = 1; /* These variables are reset by input_scrub_push. Restore them @@ -293,20 +303,21 @@ void input_scrub_close (void) { input_file_close (); + physical_input_line = 0; + logical_input_line = -1; } char * input_scrub_next_buffer (char **bufp) { - register char *limit; /*->just after last char of buffer. */ + char *limit; /*->just after last char of buffer. */ - if (sb_index >= 0) + if (sb_index != (size_t) -1) { if (sb_index >= from_sb.len) { sb_kill (&from_sb); - if (from_sb_is_expansion - ) + if (from_sb_is_expansion) { cond_finish_check (macro_nest); #ifdef md_macro_end @@ -317,6 +328,7 @@ input_scrub_next_buffer (char **bufp) } --macro_nest; partial_where = NULL; + partial_size = 0; if (next_saved_file != NULL) *bufp = input_scrub_pop (next_saved_file); return partial_where; @@ -329,76 +341,74 @@ input_scrub_next_buffer (char **bufp) return partial_where; } - *bufp = buffer_start + BEFORE_SIZE; - if (partial_size) { - memcpy (buffer_start + BEFORE_SIZE, partial_where, - (unsigned int) partial_size); + memmove (buffer_start + BEFORE_SIZE, partial_where, partial_size); memcpy (buffer_start + BEFORE_SIZE, save_source, AFTER_SIZE); } - limit = input_file_give_next_buffer (buffer_start - + BEFORE_SIZE - + partial_size); - if (limit) - { - register char *p; /* Find last newline. */ - for (p = limit - 1; *p != '\n'; --p) - ; - ++p; + while (1) + { + char *p; + char *start = buffer_start + BEFORE_SIZE + partial_size; - while (p <= buffer_start + BEFORE_SIZE) + *bufp = buffer_start + BEFORE_SIZE; + limit = input_file_give_next_buffer (start); + if (!limit) { - int limoff; - - limoff = limit - buffer_start; - buffer_length += input_file_buffer_size (); - buffer_start = xrealloc (buffer_start, - (BEFORE_SIZE - + 2 * buffer_length - + AFTER_SIZE)); - *bufp = buffer_start + BEFORE_SIZE; - limit = input_file_give_next_buffer (buffer_start + limoff); - - if (limit == NULL) - { - as_warn (_("partial line at end of file ignored")); - partial_where = NULL; - if (next_saved_file) - *bufp = input_scrub_pop (next_saved_file); - return NULL; - } + if (!partial_size) + /* End of this file. */ + break; + + as_warn (_("end of file not at end of a line; newline inserted")); + p = buffer_start + BEFORE_SIZE + partial_size; + *p++ = '\n'; + limit = p; + } + else + { + /* Terminate the buffer to avoid confusing TC_EOL_IN_INSN. */ + *limit = '\0'; - for (p = limit - 1; *p != '\n'; --p) - ; + /* Find last newline. */ + for (p = limit - 1; *p != '\n' || TC_EOL_IN_INSN (p); --p) + if (p < start) + goto read_more; ++p; } + /* We found a newline in the newly read chars. */ partial_where = p; partial_size = limit - p; + + /* Save the fragment after that last newline. */ memcpy (save_source, partial_where, (int) AFTER_SIZE); memcpy (partial_where, AFTER_STRING, (int) AFTER_SIZE); - } - else - { - partial_where = 0; - if (partial_size > 0) - { - as_warn (_("partial line at end of file ignored")); - } - - /* Tell the listing we've finished the file. */ - LISTING_EOF (); + return partial_where; - /* If we should pop to another file at EOF, do it. */ - if (next_saved_file) + read_more: + /* Didn't find a newline. Read more text. */ + partial_size = limit - (buffer_start + BEFORE_SIZE); + if (buffer_length - input_file_buffer_size () < partial_size) { - *bufp = input_scrub_pop (next_saved_file); /* Pop state */ - /* partial_where is now correct to return, since we popped it. */ + /* Increase the buffer when it doesn't have room for the + next block of input. */ + buffer_length *= 2; + buffer_start = XRESIZEVEC (char, buffer_start, + (buffer_length + + BEFORE_SIZE + AFTER_SIZE + 1)); } } - return (partial_where); + + /* Tell the listing we've finished the file. */ + LISTING_EOF (); + + /* If we should pop to another file at EOF, do it. */ + partial_where = NULL; + if (next_saved_file) + *bufp = input_scrub_pop (next_saved_file); + + return partial_where; } /* The remaining part of this file deals with line numbers, error @@ -413,7 +423,7 @@ seen_at_least_1_file (void) void bump_line_counters (void) { - if (sb_index < 0) + if (sb_index == (size_t) -1) { ++physical_input_line; if (logical_input_line >= 0) @@ -430,17 +440,38 @@ bump_line_counters (void) Returns nonzero if the filename actually changes. */ int -new_logical_line (char *fname, /* DON'T destroy it! We point to it! */ - int line_number) +new_logical_line_flags (const char *fname, /* DON'T destroy it! We point to it! */ + int line_number, + int flags) { + switch (flags) + { + case 0: + break; + case 1: + if (line_number != -1) + abort (); + break; + case 1 << 1: + case 1 << 2: + /* FIXME: we could check that include nesting is correct. */ + break; + default: + abort (); + } + if (line_number >= 0) logical_input_line = line_number; - else if (line_number == -2 && logical_input_line > 0) - --logical_input_line; + else if (line_number == -1 && fname && !*fname && (flags & (1 << 2))) + { + logical_input_file = physical_input_file; + logical_input_line = physical_input_line; + fname = NULL; + } if (fname && (logical_input_file == NULL - || strcmp (logical_input_file, fname))) + || filename_cmp (logical_input_file, fname))) { logical_input_file = fname; return 1; @@ -448,67 +479,44 @@ new_logical_line (char *fname, /* DON'T destroy it! We point to it! */ else return 0; } - -/* Return the current file name and line number. - namep should be char * const *, but there are compilers which screw - up declarations like that, and it's easier to avoid it. */ -void -as_where (char **namep, unsigned int *linep) +int +new_logical_line (const char *fname, int line_number) { - if (logical_input_file != NULL - && (linep == NULL || logical_input_line >= 0)) - { - *namep = logical_input_file; - if (linep != NULL) - *linep = logical_input_line; - } - else if (physical_input_file != NULL) - { - *namep = physical_input_file; - if (linep != NULL) - *linep = physical_input_line; - } - else - { - *namep = 0; - if (linep != NULL) - *linep = 0; - } + return new_logical_line_flags (fname, line_number, 0); } + -/* Output to given stream how much of line we have scanned so far. - Assumes we have scanned up to and including input_line_pointer. - No free '\n' at end of line. */ +/* Return the current physical input file name and line number, if known */ -void -as_howmuch (FILE *stream /* Opened for write please. */) +const char * +as_where_physical (unsigned int *linep) { - register char *p; /* Scan input line. */ - - for (p = input_line_pointer - 1; *p != '\n'; --p) + if (physical_input_file != NULL) { + if (linep != NULL) + *linep = physical_input_line; + return physical_input_file; } - ++p; /* p->1st char of line. */ - for (; p <= input_line_pointer; p++) - { - /* Assume ASCII. EBCDIC & other micro-computer char sets ignored. */ - as_1_char ((unsigned char) *p, stream); - } + + if (linep != NULL) + *linep = 0; + return NULL; } -static void -as_1_char (unsigned int c, FILE *stream) +/* Return the current file name and line number. */ + +const char * +as_where (unsigned int *linep) { - if (c > 127) - { - (void) putc ('%', stream); - c -= 128; - } - if (c < 32) + if (logical_input_file != NULL + && (linep == NULL || logical_input_line >= 0)) { - (void) putc ('^', stream); - c += '@'; + if (linep != NULL) + *linep = logical_input_line; + return logical_input_file; } - (void) putc (c, stream); + + return as_where_physical (linep); } +