OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.2.2/] [gcc/] [c-ppoutput.c] - Blame information for rev 154

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
/* Preprocess only, using cpplib.
2
   Copyright (C) 1995, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007
3
   Free Software Foundation, Inc.
4
   Written by Per Bothner, 1994-95.
5
 
6
   This program is free software; you can redistribute it and/or modify it
7
   under the terms of the GNU General Public License as published by the
8
   Free Software Foundation; either version 3, or (at your option) any
9
   later version.
10
 
11
   This program 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 this program; see the file COPYING3.  If not see
18
   <http://www.gnu.org/licenses/>.  */
19
 
20
#include "config.h"
21
#include "system.h"
22
#include "coretypes.h"
23
#include "tm.h"
24
#include "cpplib.h"
25
#include "../libcpp/internal.h"
26
#include "tree.h"
27
#include "c-common.h"           /* For flags.  */
28
#include "c-pragma.h"           /* For parse_in.  */
29
 
30
/* Encapsulates state used to convert a stream of tokens into a text
31
   file.  */
32
static struct
33
{
34
  FILE *outf;                   /* Stream to write to.  */
35
  const cpp_token *prev;        /* Previous token.  */
36
  const cpp_token *source;      /* Source token for spacing.  */
37
  int src_line;                 /* Line number currently being written.  */
38
  unsigned char printed;        /* Nonzero if something output at line.  */
39
  bool first_time;              /* pp_file_change hasn't been called yet.  */
40
} print;
41
 
42
/* General output routines.  */
43
static void scan_translation_unit (cpp_reader *);
44
static void scan_translation_unit_trad (cpp_reader *);
45
static void account_for_newlines (const unsigned char *, size_t);
46
static int dump_macro (cpp_reader *, cpp_hashnode *, void *);
47
 
48
static void print_line (source_location, const char *);
49
static void maybe_print_line (source_location);
50
 
51
/* Callback routines for the parser.   Most of these are active only
52
   in specific modes.  */
53
static void cb_line_change (cpp_reader *, const cpp_token *, int);
54
static void cb_define (cpp_reader *, source_location, cpp_hashnode *);
55
static void cb_undef (cpp_reader *, source_location, cpp_hashnode *);
56
static void cb_include (cpp_reader *, source_location, const unsigned char *,
57
                        const char *, int, const cpp_token **);
58
static void cb_ident (cpp_reader *, source_location, const cpp_string *);
59
static void cb_def_pragma (cpp_reader *, source_location);
60
static void cb_read_pch (cpp_reader *pfile, const char *name,
61
                         int fd, const char *orig_name);
62
 
63
/* Preprocess and output.  */
64
void
65
preprocess_file (cpp_reader *pfile)
66
{
67
  /* A successful cpp_read_main_file guarantees that we can call
68
     cpp_scan_nooutput or cpp_get_token next.  */
69
  if (flag_no_output)
70
    {
71
      /* Scan -included buffers, then the main file.  */
72
      while (pfile->buffer->prev)
73
        cpp_scan_nooutput (pfile);
74
      cpp_scan_nooutput (pfile);
75
    }
76
  else if (cpp_get_options (pfile)->traditional)
77
    scan_translation_unit_trad (pfile);
78
  else
79
    scan_translation_unit (pfile);
80
 
81
  /* -dM command line option.  Should this be elsewhere?  */
82
  if (flag_dump_macros == 'M')
83
    cpp_forall_identifiers (pfile, dump_macro, NULL);
84
 
85
  /* Flush any pending output.  */
86
  if (print.printed)
87
    putc ('\n', print.outf);
88
}
89
 
90
/* Set up the callbacks as appropriate.  */
91
void
92
init_pp_output (FILE *out_stream)
93
{
94
  cpp_callbacks *cb = cpp_get_callbacks (parse_in);
95
 
96
  if (!flag_no_output)
97
    {
98
      cb->line_change = cb_line_change;
99
      /* Don't emit #pragma or #ident directives if we are processing
100
         assembly language; the assembler may choke on them.  */
101
      if (cpp_get_options (parse_in)->lang != CLK_ASM)
102
        {
103
          cb->ident      = cb_ident;
104
          cb->def_pragma = cb_def_pragma;
105
        }
106
    }
107
 
108
  if (flag_dump_includes)
109
    cb->include  = cb_include;
110
 
111
  if (flag_pch_preprocess)
112
    {
113
      cb->valid_pch = c_common_valid_pch;
114
      cb->read_pch = cb_read_pch;
115
    }
116
 
117
  if (flag_dump_macros == 'N' || flag_dump_macros == 'D')
118
    {
119
      cb->define = cb_define;
120
      cb->undef  = cb_undef;
121
    }
122
 
123
  /* Initialize the print structure.  Setting print.src_line to -1 here is
124
     a trick to guarantee that the first token of the file will cause
125
     a linemarker to be output by maybe_print_line.  */
126
  print.src_line = -1;
127
  print.printed = 0;
128
  print.prev = 0;
129
  print.outf = out_stream;
130
  print.first_time = 1;
131
}
132
 
133
/* Writes out the preprocessed file, handling spacing and paste
134
   avoidance issues.  */
135
static void
136
scan_translation_unit (cpp_reader *pfile)
137
{
138
  bool avoid_paste = false;
139
 
140
  print.source = NULL;
141
  for (;;)
142
    {
143
      const cpp_token *token = cpp_get_token (pfile);
144
 
145
      if (token->type == CPP_PADDING)
146
        {
147
          avoid_paste = true;
148
          if (print.source == NULL
149
              || (!(print.source->flags & PREV_WHITE)
150
                  && token->val.source == NULL))
151
            print.source = token->val.source;
152
          continue;
153
        }
154
 
155
      if (token->type == CPP_EOF)
156
        break;
157
 
158
      /* Subtle logic to output a space if and only if necessary.  */
159
      if (avoid_paste)
160
        {
161
          if (print.source == NULL)
162
            print.source = token;
163
          if (print.source->flags & PREV_WHITE
164
              || (print.prev
165
                  && cpp_avoid_paste (pfile, print.prev, token))
166
              || (print.prev == NULL && token->type == CPP_HASH))
167
            putc (' ', print.outf);
168
        }
169
      else if (token->flags & PREV_WHITE)
170
        putc (' ', print.outf);
171
 
172
      avoid_paste = false;
173
      print.source = NULL;
174
      print.prev = token;
175
      cpp_output_token (token, print.outf);
176
 
177
      if (token->type == CPP_COMMENT)
178
        account_for_newlines (token->val.str.text, token->val.str.len);
179
    }
180
}
181
 
182
/* Adjust print.src_line for newlines embedded in output.  */
183
static void
184
account_for_newlines (const unsigned char *str, size_t len)
185
{
186
  while (len--)
187
    if (*str++ == '\n')
188
      print.src_line++;
189
}
190
 
191
/* Writes out a traditionally preprocessed file.  */
192
static void
193
scan_translation_unit_trad (cpp_reader *pfile)
194
{
195
  while (_cpp_read_logical_line_trad (pfile))
196
    {
197
      size_t len = pfile->out.cur - pfile->out.base;
198
      maybe_print_line (pfile->out.first_line);
199
      fwrite (pfile->out.base, 1, len, print.outf);
200
      print.printed = 1;
201
      if (!CPP_OPTION (pfile, discard_comments))
202
        account_for_newlines (pfile->out.base, len);
203
    }
204
}
205
 
206
/* If the token read on logical line LINE needs to be output on a
207
   different line to the current one, output the required newlines or
208
   a line marker, and return 1.  Otherwise return 0.  */
209
static void
210
maybe_print_line (source_location src_loc)
211
{
212
  const struct line_map *map = linemap_lookup (&line_table, src_loc);
213
  int src_line = SOURCE_LINE (map, src_loc);
214
  /* End the previous line of text.  */
215
  if (print.printed)
216
    {
217
      putc ('\n', print.outf);
218
      print.src_line++;
219
      print.printed = 0;
220
    }
221
 
222
  if (src_line >= print.src_line && src_line < print.src_line + 8)
223
    {
224
      while (src_line > print.src_line)
225
        {
226
          putc ('\n', print.outf);
227
          print.src_line++;
228
        }
229
    }
230
  else
231
    print_line (src_loc, "");
232
}
233
 
234
/* Output a line marker for logical line LINE.  Special flags are "1"
235
   or "2" indicating entering or leaving a file.  */
236
static void
237
print_line (source_location src_loc, const char *special_flags)
238
{
239
  /* End any previous line of text.  */
240
  if (print.printed)
241
    putc ('\n', print.outf);
242
  print.printed = 0;
243
 
244
  if (!flag_no_line_commands)
245
    {
246
      const struct line_map *map = linemap_lookup (&line_table, src_loc);
247
 
248
      size_t to_file_len = strlen (map->to_file);
249
      unsigned char *to_file_quoted =
250
         (unsigned char *) alloca (to_file_len * 4 + 1);
251
      unsigned char *p;
252
 
253
      print.src_line = SOURCE_LINE (map, src_loc);
254
 
255
      /* cpp_quote_string does not nul-terminate, so we have to do it
256
         ourselves.  */
257
      p = cpp_quote_string (to_file_quoted,
258
                            (unsigned char *) map->to_file, to_file_len);
259
      *p = '\0';
260
      fprintf (print.outf, "# %u \"%s\"%s",
261
               print.src_line == 0 ? 1 : print.src_line,
262
               to_file_quoted, special_flags);
263
 
264
      if (map->sysp == 2)
265
        fputs (" 3 4", print.outf);
266
      else if (map->sysp == 1)
267
        fputs (" 3", print.outf);
268
 
269
      putc ('\n', print.outf);
270
    }
271
}
272
 
273
/* Called when a line of output is started.  TOKEN is the first token
274
   of the line, and at end of file will be CPP_EOF.  */
275
static void
276
cb_line_change (cpp_reader *pfile, const cpp_token *token,
277
                int parsing_args)
278
{
279
  source_location src_loc = token->src_loc;
280
 
281
  if (token->type == CPP_EOF || parsing_args)
282
    return;
283
 
284
  maybe_print_line (src_loc);
285
  print.prev = 0;
286
  print.source = 0;
287
 
288
  /* Supply enough spaces to put this token in its original column,
289
     one space per column greater than 2, since scan_translation_unit
290
     will provide a space if PREV_WHITE.  Don't bother trying to
291
     reconstruct tabs; we can't get it right in general, and nothing
292
     ought to care.  Some things do care; the fault lies with them.  */
293
  if (!CPP_OPTION (pfile, traditional))
294
    {
295
      const struct line_map *map = linemap_lookup (&line_table, src_loc);
296
      int spaces = SOURCE_COLUMN (map, src_loc) - 2;
297
      print.printed = 1;
298
 
299
      while (-- spaces >= 0)
300
        putc (' ', print.outf);
301
    }
302
}
303
 
304
static void
305
cb_ident (cpp_reader *pfile ATTRIBUTE_UNUSED, source_location line,
306
          const cpp_string *str)
307
{
308
  maybe_print_line (line);
309
  fprintf (print.outf, "#ident %s\n", str->text);
310
  print.src_line++;
311
}
312
 
313
static void
314
cb_define (cpp_reader *pfile, source_location line, cpp_hashnode *node)
315
{
316
  maybe_print_line (line);
317
  fputs ("#define ", print.outf);
318
 
319
  /* 'D' is whole definition; 'N' is name only.  */
320
  if (flag_dump_macros == 'D')
321
    fputs ((const char *) cpp_macro_definition (pfile, node),
322
           print.outf);
323
  else
324
    fputs ((const char *) NODE_NAME (node), print.outf);
325
 
326
  putc ('\n', print.outf);
327
  if (linemap_lookup (&line_table, line)->to_line != 0)
328
    print.src_line++;
329
}
330
 
331
static void
332
cb_undef (cpp_reader *pfile ATTRIBUTE_UNUSED, source_location line,
333
          cpp_hashnode *node)
334
{
335
  maybe_print_line (line);
336
  fprintf (print.outf, "#undef %s\n", NODE_NAME (node));
337
  print.src_line++;
338
}
339
 
340
static void
341
cb_include (cpp_reader *pfile ATTRIBUTE_UNUSED, source_location line,
342
            const unsigned char *dir, const char *header, int angle_brackets,
343
            const cpp_token **comments)
344
{
345
  maybe_print_line (line);
346
  if (angle_brackets)
347
    fprintf (print.outf, "#%s <%s>", dir, header);
348
  else
349
    fprintf (print.outf, "#%s \"%s\"", dir, header);
350
 
351
  if (comments != NULL)
352
    {
353
      while (*comments != NULL)
354
        {
355
          if ((*comments)->flags & PREV_WHITE)
356
            putc (' ', print.outf);
357
          cpp_output_token (*comments, print.outf);
358
          ++comments;
359
        }
360
    }
361
 
362
  putc ('\n', print.outf);
363
  print.src_line++;
364
}
365
 
366
/* Callback called when -fworking-director and -E to emit working
367
   directory in cpp output file.  */
368
 
369
void
370
pp_dir_change (cpp_reader *pfile ATTRIBUTE_UNUSED, const char *dir)
371
{
372
  size_t to_file_len = strlen (dir);
373
  unsigned char *to_file_quoted =
374
     (unsigned char *) alloca (to_file_len * 4 + 1);
375
  unsigned char *p;
376
 
377
  /* cpp_quote_string does not nul-terminate, so we have to do it ourselves.  */
378
  p = cpp_quote_string (to_file_quoted, (unsigned char *) dir, to_file_len);
379
  *p = '\0';
380
  fprintf (print.outf, "# 1 \"%s//\"\n", to_file_quoted);
381
}
382
 
383
/* The file name, line number or system header flags have changed, as
384
   described in MAP.  */
385
 
386
void
387
pp_file_change (const struct line_map *map)
388
{
389
  const char *flags = "";
390
 
391
  if (flag_no_line_commands)
392
    return;
393
 
394
  if (map != NULL)
395
    {
396
      if (print.first_time)
397
        {
398
          /* Avoid printing foo.i when the main file is foo.c.  */
399
          if (!cpp_get_options (parse_in)->preprocessed)
400
            print_line (map->start_location, flags);
401
          print.first_time = 0;
402
        }
403
      else
404
        {
405
          /* Bring current file to correct line when entering a new file.  */
406
          if (map->reason == LC_ENTER)
407
            {
408
              const struct line_map *from = INCLUDED_FROM (&line_table, map);
409
              maybe_print_line (LAST_SOURCE_LINE_LOCATION (from));
410
            }
411
          if (map->reason == LC_ENTER)
412
            flags = " 1";
413
          else if (map->reason == LC_LEAVE)
414
            flags = " 2";
415
          print_line (map->start_location, flags);
416
        }
417
    }
418
}
419
 
420
/* Copy a #pragma directive to the preprocessed output.  */
421
static void
422
cb_def_pragma (cpp_reader *pfile, source_location line)
423
{
424
  maybe_print_line (line);
425
  fputs ("#pragma ", print.outf);
426
  cpp_output_line (pfile, print.outf);
427
  print.src_line++;
428
}
429
 
430
/* Dump out the hash table.  */
431
static int
432
dump_macro (cpp_reader *pfile, cpp_hashnode *node, void *v ATTRIBUTE_UNUSED)
433
{
434
  if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
435
    {
436
      fputs ("#define ", print.outf);
437
      fputs ((const char *) cpp_macro_definition (pfile, node),
438
             print.outf);
439
      putc ('\n', print.outf);
440
      print.src_line++;
441
    }
442
 
443
  return 1;
444
}
445
 
446
/* Load in the PCH file NAME, open on FD.  It was originally searched for
447
   by ORIG_NAME.  Also, print out a #include command so that the PCH
448
   file can be loaded when the preprocessed output is compiled.  */
449
 
450
static void
451
cb_read_pch (cpp_reader *pfile, const char *name,
452
             int fd, const char *orig_name ATTRIBUTE_UNUSED)
453
{
454
  c_common_read_pch (pfile, name, fd, orig_name);
455
 
456
  fprintf (print.outf, "#pragma GCC pch_preprocess \"%s\"\n", name);
457
  print.src_line++;
458
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.