Return to input-scrub.c CVS log

Up to [Apple XNU] / GNUtools / cctools / as

Annotation of GNUtools/cctools/as/input-scrub.c, revision 1.1

1.1     ! root        1: /* input_scrub.c - layer between app and the rest of the world
        !             2:    Copyright (C) 1987 Free Software Foundation, Inc.
        !             3: 
        !             4: This file is part of GAS, the GNU Assembler.
        !             5: 
        !             6: GAS is free software; you can redistribute it and/or modify
        !             7: it under the terms of the GNU General Public License as published by
        !             8: the Free Software Foundation; either version 1, or (at your option)
        !             9: any later version.
        !            10: 
        !            11: GAS is distributed in the hope that it will be useful,
        !            12: but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        !            14: GNU General Public License for more details.
        !            15: 
        !            16: You should have received a copy of the GNU General Public License
        !            17: along with GAS; see the file COPYING.  If not, write to
        !            18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
        !            19: 
        !            20: #include <stdlib.h>
        !            21: #include <string.h>
        !            22: #include <errno.h>
        !            23: #include <libc.h>
        !            24: #ifdef NeXT    /* .include feature */
        !            25: #include <sys/file.h>
        !            26: #include <sys/param.h>
        !            27: #endif /* NeXT .include feature */
        !            28: #include "as.h"
        !            29: #include "read.h"
        !            30: #include "input-file.h"
        !            31: #include "input-scrub.h"
        !            32: #include "app.h"
        !            33: #include "xmalloc.h"
        !            34: #include "messages.h"
        !            35: 
        !            36: /*
        !            37:  * O/S independent module to supply buffers of sanitised source code
        !            38:  * to rest of assembler. We get raw input data of some length.
        !            39:  * Also looks after line numbers, for e.g. error messages.
        !            40:  * This module used to do the sanitising, but now a pre-processor program
        !            41:  * (app) does that job so this module is degenerate.
        !            42:  * Now input is pre-sanitised, so we only worry about finding the
        !            43:  * last partial line. A buffer of full lines is returned to caller.
        !            44:  * The last partial line begins the next buffer we build and return to caller.
        !            45:  * The buffer returned to caller is preceeded by BEFORE_STRING and followed
        !            46:  * by AFTER_STRING. The last character before AFTER_STRING is a newline.
        !            47:  */
        !            48: 
        !            49: /*
        !            50:  * We expect the following sanitation has already been done.
        !            51:  *
        !            52:  * No comments, reduce a comment to a space.
        !            53:  * Reduce a tab to a space unless it is 1st char of line.
        !            54:  * All multiple tabs and spaces collapsed into 1 char. Tab only
        !            55:  *   legal if 1st char of line.
        !            56:  * # line file statements converted to .line x;.file y; statements.
        !            57:  * Escaped newlines at end of line: remove them but add as many newlines
        !            58:  *   to end of statement as you removed in the middle, to synch line numbers.
        !            59:  */
        !            60: 
        !            61: #define BEFORE_STRING ("\n")
        !            62: #define AFTER_STRING ("\0")    /* memcpy of 0 chars might choke. */
        !            63: #define BEFORE_SIZE (1)
        !            64: #define AFTER_SIZE  (1)                /* includes the \0 */
        !            65: 
        !            66: static char *  buffer_start;   /* -> 1st char of full buffer area. */
        !            67: static char *  partial_where;  /* -> after last full line in buffer. */
        !            68: static int     partial_size;   /* >=0. Number of chars in partial line in buffer. */
        !            69: static char    save_source [AFTER_SIZE];
        !            70:                                /* Because we need AFTER_STRING just after last */
        !            71:                                /* full line, it clobbers 1st part of partial */
        !            72:                                /* line. So we preserve 1st part of partial */
        !            73:                                /* line here. */
        !            74: static int     buffer_length;  /* What is the largest size buffer that */
        !            75:                                /* input_file_give_next_buffer() could */
        !            76:                                /* return to us? */
        !            77: 
        !            78: /*
        !            79: We never have more than one source file open at once.
        !            80: We may, however, read more than 1 source file in an assembly.
        !            81: NULL means we have no file open right now.
        !            82: */
        !            83: 
        !            84: 
        !            85: /*
        !            86: We must track the physical file and line number for error messages.
        !            87: We also track a "logical" file and line number corresponding to (C?)
        !            88: compiler source line numbers.
        !            89: Whenever we open a file we must fill in physical_input_file. So if it is NULL
        !            90: we have not opened any files yet.
        !            91: */
        !            92: 
        !            93: int doing_include = FALSE; /* TRUE when we are processing a .include */
        !            94: 
        !            95: char *physical_input_file = NULL;
        !            96: char *logical_input_file = NULL;
        !            97: 
        !            98: line_numberT physical_input_line = 0;
        !            99: line_numberT logical_input_line = 0;
        !           100: 
        !           101: 
        !           102: void
        !           103: input_scrub_begin(
        !           104: void)
        !           105: {
        !           106:   know( strlen(BEFORE_STRING)    == BEFORE_SIZE );
        !           107:   know( strlen(AFTER_STRING) + 1 ==  AFTER_SIZE );
        !           108: 
        !           109:   input_file_begin ();
        !           110: 
        !           111:   buffer_length = input_file_buffer_size ();
        !           112: 
        !           113:   buffer_start = xmalloc ((long)(BEFORE_SIZE + buffer_length + buffer_length + AFTER_SIZE));
        !           114:   memcpy(buffer_start, BEFORE_STRING, (int)BEFORE_SIZE);
        !           115: 
        !           116:   /* Line number things. */
        !           117:   logical_input_line = 0;
        !           118:   logical_input_file = (char *)NULL;
        !           119:   physical_input_file = NULL;  /* No file read yet. */
        !           120:   do_scrub_begin();
        !           121: }
        !           122: 
        !           123: void
        !           124: input_scrub_end(
        !           125: void)
        !           126: {
        !           127:   input_file_end ();
        !           128: }
        !           129: 
        !           130: char *                         /* Return start of caller's part of buffer. */
        !           131: input_scrub_new_file(
        !           132: char *filename)
        !           133: {
        !           134:   input_file_open (filename, !flagseen['f']);
        !           135:   physical_input_file = filename[0] ? filename : "{standard input}";
        !           136:   physical_input_line = 0;
        !           137: 
        !           138:   partial_size = 0;
        !           139:   return (buffer_start + BEFORE_SIZE);
        !           140: }
        !           141: 
        !           142: char *
        !           143: input_scrub_next_buffer(
        !           144: char **bufp)
        !           145: {
        !           146:   register char *      limit;  /* -> just after last char of buffer. */
        !           147: 
        !           148:   if (partial_size)
        !           149:     {
        !           150:       memcpy(buffer_start + BEFORE_SIZE, partial_where, (int)partial_size);
        !           151:       memcpy(buffer_start + BEFORE_SIZE, save_source, (int)AFTER_SIZE);
        !           152:     }
        !           153:   limit = input_file_give_next_buffer (buffer_start + BEFORE_SIZE + partial_size);
        !           154:   if (limit)
        !           155:     {
        !           156:       register char *  p;      /* Find last newline. */
        !           157: 
        !           158:       for (p = limit;   * -- p != '\n';   )
        !           159:        {
        !           160:        }
        !           161:       ++ p;
        !           162:       if (p <= buffer_start + BEFORE_SIZE)
        !           163:        {
        !           164:          as_fatal ("Source line too long. Please change file %s then rebuild assembler.", __FILE__);
        !           165:        }
        !           166:       partial_where = p;
        !           167:       partial_size = limit - p;
        !           168:       memcpy(save_source, partial_where, (int)AFTER_SIZE);
        !           169:       memcpy(partial_where, AFTER_STRING, (int)AFTER_SIZE);
        !           170:     }
        !           171:   else
        !           172:     {
        !           173:       partial_where = 0;
        !           174:       if (partial_size > 0)
        !           175:        {
        !           176:          as_warn( "Partial line at end of file ignored" );
        !           177:        }
        !           178:     }
        !           179:   return (partial_where);
        !           180: }
        !           181: 
        !           182: /*
        !           183:  * The remaining part of this file deals with line numbers, error
        !           184:  * messages and so on.
        !           185:  */
        !           186: 
        !           187: 
        !           188: /*
        !           189:  * seen_at_least_1_file() returns TRUE if we opened any file.
        !           190:  */
        !           191: int
        !           192: seen_at_least_1_file(
        !           193: void)
        !           194: {
        !           195:   return (physical_input_file != NULL);
        !           196: }
        !           197: 
        !           198: void
        !           199: bump_line_counters(
        !           200: void)
        !           201: {
        !           202:   ++ physical_input_line;
        !           203:   ++ logical_input_line;
        !           204: }
        !           205: 
        !           206: /*
        !           207:  *                     new_logical_line()
        !           208:  *
        !           209:  * Tells us what the new logical line number and file are.
        !           210:  * If the line_number is <0, we don't change the current logical line number.
        !           211:  * If the fname is NULL, we don't change the current logical file name.
        !           212:  */
        !           213: void
        !           214: new_logical_line(
        !           215: char *fname,           /* DON'T destroy it! We point to it! */
        !           216: int line_number)
        !           217: {
        !           218:   if ( fname )
        !           219:     {
        !           220:       logical_input_file = fname;
        !           221:     }
        !           222:   if ( line_number >= 0 )
        !           223:     {
        !           224:       logical_input_line = line_number;
        !           225:     }
        !           226: }
        !           227: 
        !           228: /*
        !           229:  *                     a s _ w h e r e ( )
        !           230:  *
        !           231:  * Write a line to stderr locating where we are in reading
        !           232:  * input source files.
        !           233:  * As a sop to the debugger of AS, pretty-print the offending line.
        !           234:  */
        !           235: void
        !           236: as_where(
        !           237: void)
        !           238: {
        !           239:   char *p;
        !           240:   line_numberT line;
        !           241: 
        !           242:   if (physical_input_file)
        !           243:     {                          /* we tried to read SOME source */
        !           244:       if (input_file_is_open())
        !           245:        {                       /* we can still read lines from source */
        !           246:                p = logical_input_file ? logical_input_file : physical_input_file;
        !           247:                line = logical_input_line ? logical_input_line : physical_input_line;
        !           248:                fprintf(stderr,"%s:%u:", p, line);
        !           249:        }
        !           250:       else
        !           251:        {
        !           252:        p = logical_input_file ? logical_input_file : physical_input_file;
        !           253:        line = logical_input_line ? logical_input_line : physical_input_line;
        !           254:        fprintf (stderr,"%s:unknown:", p);
        !           255:        }
        !           256:     }
        !           257:   else
        !           258:     {
        !           259:     }
        !           260: }
        !           261: 
        !           262: /*
        !           263:  * as_where_ProjectBuilder() returns the fileName, directory, and line number
        !           264:  * to be used to tell ProjectBuilder where the error is.  Note that the '/'
        !           265:  * between fileName and directory does not appear in what is returned.
        !           266:  */
        !           267: void
        !           268: as_where_ProjectBuilder(
        !           269: char **fileName,
        !           270: char **directory,
        !           271: int *line)
        !           272: {
        !           273:     char *p, *q;
        !           274:     static char directory_buf[MAXPATHLEN];
        !           275: 
        !           276:        getwd(directory_buf);
        !           277:        *fileName = NULL;
        !           278:        *directory = directory_buf;
        !           279:        *line = 0;
        !           280: 
        !           281:        if(physical_input_file){
        !           282:            p = logical_input_file ?
        !           283:                logical_input_file : physical_input_file;
        !           284:            if(input_file_is_open()){
        !           285:                *line = logical_input_line ?
        !           286:                        logical_input_line : physical_input_line;
        !           287:            }
        !           288:            *fileName = p;
        !           289:            q = strrchr(p, '/');
        !           290:            if(q == NULL)
        !           291:                return;
        !           292:            *fileName = p + 1;
        !           293:            strncat(directory_buf, p, q - p);
        !           294:        }
        !           295: }
        !           296: 
        !           297: /*
        !           298:  *                     a s _ p e r r o r
        !           299:  *
        !           300:  * Like perror(3), but with more info.
        !           301:  */
        !           302: void
        !           303: as_perror(
        !           304: char *gripe,           /* Unpunctuated error theme. */
        !           305: char *filename)
        !           306: {
        !           307:   fprintf (stderr,"as:file(%s) %s! ",
        !           308:           filename, gripe
        !           309:           );
        !           310:   if (errno > sys_nerr)
        !           311:     {
        !           312:       fprintf (stderr, "Unknown error #%d.", errno);
        !           313:     }
        !           314:   else
        !           315:     {
        !           316:       fprintf (stderr, "%s.", sys_errlist [errno]);
        !           317:     }
        !           318:   (void)putc('\n', stderr);
        !           319:   errno = 0;                   /* After reporting, clear it. */
        !           320:   if (input_file_is_open())    /* RMS says don't mention line # if not needed. */
        !           321:     {
        !           322:       as_where();
        !           323:     }
        !           324: }
        !           325: 
        !           326: 
        !           327: #ifdef NeXT    /* .include feature */
        !           328: /* DJA -- added for .include pseudo op support */
        !           329: void
        !           330: read_an_include_file(
        !           331: char *no_path_name)
        !           332: {
        !           333:   char                                 * buffer;
        !           334:   char                                 * last_buffer_limit;
        !           335:   char                                 * last_buffer_start;
        !           336:   int                                    last_doing_include;
        !           337:   FILE                                 * last_f_in;
        !           338:   char                                 * last_file_name;
        !           339:   char                                 * last_input_line_pointer;
        !           340:   char                                 * last_logical_input_file;
        !           341:   line_numberT                           last_logical_input_line;
        !           342:   int                                    last_partial_size;
        !           343:   char                                 * last_partial_where;
        !           344:   char                                 * last_physical_input_file;
        !           345:   line_numberT                           last_physical_input_line;
        !           346:   char                                   last_save_source [AFTER_SIZE];
        !           347: #if 0
        !           348:   char                                 * last_save_buffer;
        !           349: #endif
        !           350:   char                                   name_buffer [MAXPATHLEN];
        !           351:   scrub_context_data                     scrub_context;
        !           352:   register struct directory_stack      * the_path_pointer;
        !           353:   register char                                * whole_file_name;
        !           354: 
        !           355:  /*
        !           356:   * figure out what directory the file name is in.
        !           357:   */
        !           358:   whole_file_name = no_path_name;
        !           359:   if (access(whole_file_name, R_OK))
        !           360:     {
        !           361:       whole_file_name = name_buffer;
        !           362:       the_path_pointer = include;
        !           363:       while (the_path_pointer)
        !           364:         {
        !           365:          if (strlen (the_path_pointer->fname) + (strlen (no_path_name)) >= MAXPATHLEN)
        !           366:            as_warn ("include file name too long: \"%s%s\"", the_path_pointer->fname, no_path_name);
        !           367:          else
        !           368:            {
        !           369:              *whole_file_name = '\0';
        !           370:              strcpy (whole_file_name, the_path_pointer->fname);
        !           371:              strcat (whole_file_name, "/");
        !           372:              strcat (whole_file_name, no_path_name);
        !           373:              if (!access(whole_file_name, R_OK))
        !           374:                goto found;
        !           375:            }
        !           376:          the_path_pointer = the_path_pointer->next;
        !           377:        }
        !           378:       the_path_pointer = include_defaults;
        !           379:       while (the_path_pointer->fname != NULL)
        !           380:         {
        !           381:          if (strlen (the_path_pointer->fname) + (strlen (no_path_name)) >= MAXPATHLEN)
        !           382:            as_warn ("include file name too long: \"%s%s\"", the_path_pointer->fname, no_path_name);
        !           383:          else
        !           384:            {
        !           385:              *whole_file_name = '\0';
        !           386:              strcpy (whole_file_name, the_path_pointer->fname);
        !           387:              strcat (whole_file_name, "/");
        !           388:              strcat (whole_file_name, no_path_name);
        !           389:              if (!access(whole_file_name, R_OK))
        !           390:                goto found;
        !           391:            }
        !           392:          the_path_pointer++;
        !           393:        }
        !           394:       as_fatal ("Couldn't find the include file: \"%s\"", no_path_name);
        !           395:       return;
        !           396:     }
        !           397: found:
        !           398:  /*
        !           399:   * save a copy of the file state for a recursive call to read a file
        !           400:   */
        !           401:   last_buffer_limit = buffer_limit;
        !           402:   last_buffer_start = buffer_start;
        !           403:   last_doing_include = doing_include;
        !           404:   last_f_in = f_in;
        !           405:   last_file_name = file_name;
        !           406:   last_input_line_pointer = input_line_pointer;
        !           407:   last_logical_input_file = logical_input_file;
        !           408:   last_logical_input_line = logical_input_line;
        !           409:   last_partial_size = partial_size;
        !           410:   last_partial_where = partial_where;
        !           411:   last_physical_input_file = physical_input_file;
        !           412:   last_physical_input_line = physical_input_line;
        !           413:   memcpy(last_save_source, save_source, sizeof (save_source));
        !           414:   save_scrub_context (&scrub_context);
        !           415:  /*
        !           416:   * set up for another file
        !           417:   */
        !           418:   partial_size = 0;
        !           419:   doing_include = TRUE;
        !           420:   input_scrub_begin ();
        !           421:   buffer = input_scrub_new_file (whole_file_name);
        !           422:   if (f_in != (FILE *)0)
        !           423:     read_a_source_file(buffer);
        !           424: 
        !           425:   xfree (buffer_start);
        !           426:  /*
        !           427:   * restore the file state
        !           428:   */
        !           429:   buffer_limit = last_buffer_limit;
        !           430:   buffer_start = last_buffer_start;
        !           431:   doing_include = last_doing_include;
        !           432:   f_in = last_f_in;
        !           433:   file_name = last_file_name;
        !           434:   input_line_pointer = last_input_line_pointer;
        !           435:   logical_input_file = last_logical_input_file;
        !           436:   logical_input_line = last_logical_input_line;
        !           437:   partial_size = last_partial_size;
        !           438:   partial_where = last_partial_where;
        !           439:   physical_input_file = last_physical_input_file;
        !           440:   physical_input_line = last_physical_input_line;
        !           441:   memcpy(save_source, last_save_source, sizeof (save_source));
        !           442:   restore_scrub_context (&scrub_context);
        !           443: } /* read_an_include_file */
        !           444: #endif /* NeXT .include feature */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.