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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [c-pretty-print.c] - Blame information for rev 280

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 280 jeremybenn
/* Subroutines common to both C and C++ pretty-printers.
2
   Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
3
   Free Software Foundation, Inc.
4
   Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
5
 
6
This file is part of GCC.
7
 
8
GCC is free software; you can redistribute it and/or modify it under
9
the terms of the GNU General Public License as published by the Free
10
Software Foundation; either version 3, or (at your option) any later
11
version.
12
 
13
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14
WARRANTY; without even the implied warranty of MERCHANTABILITY or
15
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16
for more details.
17
 
18
You should have received a copy of the GNU General Public License
19
along with GCC; see the file COPYING3.  If not see
20
<http://www.gnu.org/licenses/>.  */
21
 
22
#include "config.h"
23
#include "system.h"
24
#include "coretypes.h"
25
#include "tm.h"
26
#include "real.h"
27
#include "fixed-value.h"
28
#include "intl.h"
29
#include "c-pretty-print.h"
30
#include "c-tree.h"
31
#include "tree-iterator.h"
32
#include "diagnostic.h"
33
 
34
/* Translate if being used for diagnostics, but not for dump files or
35
   __PRETTY_FUNCTION.  */
36
#define M_(msgid) (pp_translate_identifiers (pp) ? _(msgid) : (msgid))
37
 
38
/* The pretty-printer code is primarily designed to closely follow
39
   (GNU) C and C++ grammars.  That is to be contrasted with spaghetti
40
   codes we used to have in the past.  Following a structured
41
   approach (preferably the official grammars) is believed to make it
42
   much easier to add extensions and nifty pretty-printing effects that
43
   takes expression or declaration contexts into account.  */
44
 
45
 
46
#define pp_c_maybe_whitespace(PP)            \
47
   do {                                      \
48
     if (pp_base (PP)->padding == pp_before) \
49
       pp_c_whitespace (PP);                 \
50
   } while (0)
51
 
52
/* literal  */
53
static void pp_c_char (c_pretty_printer *, int);
54
 
55
/* postfix-expression  */
56
static void pp_c_initializer_list (c_pretty_printer *, tree);
57
static void pp_c_brace_enclosed_initializer_list (c_pretty_printer *, tree);
58
 
59
static void pp_c_multiplicative_expression (c_pretty_printer *, tree);
60
static void pp_c_additive_expression (c_pretty_printer *, tree);
61
static void pp_c_shift_expression (c_pretty_printer *, tree);
62
static void pp_c_relational_expression (c_pretty_printer *, tree);
63
static void pp_c_equality_expression (c_pretty_printer *, tree);
64
static void pp_c_and_expression (c_pretty_printer *, tree);
65
static void pp_c_exclusive_or_expression (c_pretty_printer *, tree);
66
static void pp_c_inclusive_or_expression (c_pretty_printer *, tree);
67
static void pp_c_logical_and_expression (c_pretty_printer *, tree);
68
static void pp_c_conditional_expression (c_pretty_printer *, tree);
69
static void pp_c_assignment_expression (c_pretty_printer *, tree);
70
 
71
/* declarations.  */
72
 
73
 
74
/* Helper functions.  */
75
 
76
void
77
pp_c_whitespace (c_pretty_printer *pp)
78
{
79
  pp_space (pp);
80
  pp_base (pp)->padding = pp_none;
81
}
82
 
83
void
84
pp_c_left_paren (c_pretty_printer *pp)
85
{
86
  pp_left_paren (pp);
87
  pp_base (pp)->padding = pp_none;
88
}
89
 
90
void
91
pp_c_right_paren (c_pretty_printer *pp)
92
{
93
  pp_right_paren (pp);
94
  pp_base (pp)->padding = pp_none;
95
}
96
 
97
void
98
pp_c_left_brace (c_pretty_printer *pp)
99
{
100
  pp_left_brace (pp);
101
  pp_base (pp)->padding = pp_none;
102
}
103
 
104
void
105
pp_c_right_brace (c_pretty_printer *pp)
106
{
107
  pp_right_brace (pp);
108
  pp_base (pp)->padding = pp_none;
109
}
110
 
111
void
112
pp_c_left_bracket (c_pretty_printer *pp)
113
{
114
  pp_left_bracket (pp);
115
  pp_base (pp)->padding = pp_none;
116
}
117
 
118
void
119
pp_c_right_bracket (c_pretty_printer *pp)
120
{
121
  pp_right_bracket (pp);
122
  pp_base (pp)->padding = pp_none;
123
}
124
 
125
void
126
pp_c_dot (c_pretty_printer *pp)
127
{
128
  pp_dot (pp);
129
  pp_base (pp)->padding = pp_none;
130
}
131
 
132
void
133
pp_c_ampersand (c_pretty_printer *pp)
134
{
135
  pp_ampersand (pp);
136
  pp_base (pp)->padding = pp_none;
137
}
138
 
139
void
140
pp_c_star (c_pretty_printer *pp)
141
{
142
  pp_star (pp);
143
  pp_base (pp)->padding = pp_none;
144
}
145
 
146
void
147
pp_c_arrow (c_pretty_printer *pp)
148
{
149
  pp_arrow (pp);
150
  pp_base (pp)->padding = pp_none;
151
}
152
 
153
void
154
pp_c_semicolon (c_pretty_printer *pp)
155
{
156
  pp_semicolon (pp);
157
  pp_base (pp)->padding = pp_none;
158
}
159
 
160
void
161
pp_c_complement (c_pretty_printer *pp)
162
{
163
  pp_complement (pp);
164
  pp_base (pp)->padding = pp_none;
165
}
166
 
167
void
168
pp_c_exclamation (c_pretty_printer *pp)
169
{
170
  pp_exclamation (pp);
171
  pp_base (pp)->padding = pp_none;
172
}
173
 
174
/* Print out the external representation of CV-QUALIFIER.  */
175
 
176
static void
177
pp_c_cv_qualifier (c_pretty_printer *pp, const char *cv)
178
{
179
  const char *p = pp_last_position_in_text (pp);
180
  /* The C programming language does not have references, but it is much
181
     simpler to handle those here rather than going through the same
182
     logic in the C++ pretty-printer.  */
183
  if (p != NULL && (*p == '*' || *p == '&'))
184
    pp_c_whitespace (pp);
185
  pp_c_ws_string (pp, cv);
186
}
187
 
188
/* Pretty-print T using the type-cast notation '( type-name )'.  */
189
 
190
static void
191
pp_c_type_cast (c_pretty_printer *pp, tree t)
192
{
193
  pp_c_left_paren (pp);
194
  pp_type_id (pp, t);
195
  pp_c_right_paren (pp);
196
}
197
 
198
/* We're about to pretty-print a pointer type as indicated by T.
199
   Output a whitespace, if needed, preparing for subsequent output.  */
200
 
201
void
202
pp_c_space_for_pointer_operator (c_pretty_printer *pp, tree t)
203
{
204
  if (POINTER_TYPE_P (t))
205
    {
206
      tree pointee = strip_pointer_operator (TREE_TYPE (t));
207
      if (TREE_CODE (pointee) != ARRAY_TYPE
208
          && TREE_CODE (pointee) != FUNCTION_TYPE)
209
        pp_c_whitespace (pp);
210
    }
211
}
212
 
213
 
214
/* Declarations.  */
215
 
216
/* C++ cv-qualifiers are called type-qualifiers in C.  Print out the
217
   cv-qualifiers of T.  If T is a declaration then it is the cv-qualifier
218
   of its type.  Take care of possible extensions.
219
 
220
   type-qualifier-list:
221
       type-qualifier
222
       type-qualifier-list type-qualifier
223
 
224
   type-qualifier:
225
       const
226
       restrict                              -- C99
227
       __restrict__                          -- GNU C
228
       address-space-qualifier               -- GNU C
229
       volatile
230
 
231
   address-space-qualifier:
232
       identifier                            -- GNU C  */
233
 
234
void
235
pp_c_type_qualifier_list (c_pretty_printer *pp, tree t)
236
{
237
  int qualifiers;
238
 
239
  if (!t || t == error_mark_node)
240
    return;
241
 
242
  if (!TYPE_P (t))
243
    t = TREE_TYPE (t);
244
 
245
  qualifiers = TYPE_QUALS (t);
246
  if (qualifiers & TYPE_QUAL_CONST)
247
    pp_c_cv_qualifier (pp, "const");
248
  if (qualifiers & TYPE_QUAL_VOLATILE)
249
    pp_c_cv_qualifier (pp, "volatile");
250
  if (qualifiers & TYPE_QUAL_RESTRICT)
251
    pp_c_cv_qualifier (pp, flag_isoc99 ? "restrict" : "__restrict__");
252
 
253
  if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (t)))
254
    {
255
      const char *as = c_addr_space_name (TYPE_ADDR_SPACE (t));
256
      pp_c_identifier (pp, as);
257
    }
258
}
259
 
260
/* pointer:
261
      * type-qualifier-list(opt)
262
      * type-qualifier-list(opt) pointer  */
263
 
264
static void
265
pp_c_pointer (c_pretty_printer *pp, tree t)
266
{
267
  if (!TYPE_P (t) && TREE_CODE (t) != TYPE_DECL)
268
    t = TREE_TYPE (t);
269
  switch (TREE_CODE (t))
270
    {
271
    case POINTER_TYPE:
272
      /* It is easier to handle C++ reference types here.  */
273
    case REFERENCE_TYPE:
274
      if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE)
275
        pp_c_pointer (pp, TREE_TYPE (t));
276
      if (TREE_CODE (t) == POINTER_TYPE)
277
        pp_c_star (pp);
278
      else
279
        pp_c_ampersand (pp);
280
      pp_c_type_qualifier_list (pp, t);
281
      break;
282
 
283
      /* ??? This node is now in GENERIC and so shouldn't be here.  But
284
         we'll fix that later.  */
285
    case DECL_EXPR:
286
      pp_declaration (pp, DECL_EXPR_DECL (t));
287
      pp_needs_newline (pp) = true;
288
      break;
289
 
290
    default:
291
      pp_unsupported_tree (pp, t);
292
    }
293
}
294
 
295
/* type-specifier:
296
      void
297
      char
298
      short
299
      int
300
      long
301
      float
302
      double
303
      signed
304
      unsigned
305
      _Bool                          -- C99
306
      _Complex                       -- C99
307
      _Imaginary                     -- C99
308
      struct-or-union-specifier
309
      enum-specifier
310
      typedef-name.
311
 
312
  GNU extensions.
313
  simple-type-specifier:
314
      __complex__
315
      __vector__   */
316
 
317
void
318
pp_c_type_specifier (c_pretty_printer *pp, tree t)
319
{
320
  const enum tree_code code = TREE_CODE (t);
321
  switch (code)
322
    {
323
    case ERROR_MARK:
324
      pp_c_ws_string (pp, M_("<type-error>"));
325
      break;
326
 
327
    case IDENTIFIER_NODE:
328
      pp_c_tree_decl_identifier (pp, t);
329
      break;
330
 
331
    case VOID_TYPE:
332
    case BOOLEAN_TYPE:
333
    case INTEGER_TYPE:
334
    case REAL_TYPE:
335
    case FIXED_POINT_TYPE:
336
      if (TYPE_NAME (t))
337
        {
338
          t = TYPE_NAME (t);
339
          pp_c_type_specifier (pp, t);
340
        }
341
      else
342
        {
343
          int prec = TYPE_PRECISION (t);
344
          if (ALL_FIXED_POINT_MODE_P (TYPE_MODE (t)))
345
            t = c_common_type_for_mode (TYPE_MODE (t), TYPE_SATURATING (t));
346
          else
347
            t = c_common_type_for_mode (TYPE_MODE (t), TYPE_UNSIGNED (t));
348
          if (TYPE_NAME (t))
349
            {
350
              pp_c_type_specifier (pp, t);
351
              if (TYPE_PRECISION (t) != prec)
352
                {
353
                  pp_string (pp, ":");
354
                  pp_decimal_int (pp, prec);
355
                }
356
            }
357
          else
358
            {
359
              switch (code)
360
                {
361
                case INTEGER_TYPE:
362
                  pp_string (pp, (TYPE_UNSIGNED (t)
363
                                  ? M_("<unnamed-unsigned:")
364
                                  : M_("<unnamed-signed:")));
365
                  break;
366
                case REAL_TYPE:
367
                  pp_string (pp, M_("<unnamed-float:"));
368
                  break;
369
                case FIXED_POINT_TYPE:
370
                  pp_string (pp, M_("<unnamed-fixed:"));
371
                  break;
372
                default:
373
                  gcc_unreachable ();
374
                }
375
              pp_decimal_int (pp, prec);
376
              pp_string (pp, ">");
377
            }
378
        }
379
      break;
380
 
381
    case TYPE_DECL:
382
      if (DECL_NAME (t))
383
        pp_id_expression (pp, t);
384
      else
385
        pp_c_ws_string (pp, M_("<typedef-error>"));
386
      break;
387
 
388
    case UNION_TYPE:
389
    case RECORD_TYPE:
390
    case ENUMERAL_TYPE:
391
      if (code == UNION_TYPE)
392
        pp_c_ws_string (pp, "union");
393
      else if (code == RECORD_TYPE)
394
        pp_c_ws_string (pp, "struct");
395
      else if (code == ENUMERAL_TYPE)
396
        pp_c_ws_string (pp, "enum");
397
      else
398
        pp_c_ws_string (pp, M_("<tag-error>"));
399
 
400
      if (TYPE_NAME (t))
401
        pp_id_expression (pp, TYPE_NAME (t));
402
      else
403
        pp_c_ws_string (pp, M_("<anonymous>"));
404
      break;
405
 
406
    default:
407
      pp_unsupported_tree (pp, t);
408
      break;
409
    }
410
}
411
 
412
/* specifier-qualifier-list:
413
      type-specifier specifier-qualifier-list-opt
414
      type-qualifier specifier-qualifier-list-opt
415
 
416
 
417
  Implementation note:  Because of the non-linearities in array or
418
  function declarations, this routine prints not just the
419
  specifier-qualifier-list of such entities or types of such entities,
420
  but also the 'pointer' production part of their declarators.  The
421
  remaining part is done by pp_declarator or pp_c_abstract_declarator.  */
422
 
423
void
424
pp_c_specifier_qualifier_list (c_pretty_printer *pp, tree t)
425
{
426
  const enum tree_code code = TREE_CODE (t);
427
 
428
  if (TREE_CODE (t) != POINTER_TYPE)
429
    pp_c_type_qualifier_list (pp, t);
430
  switch (code)
431
    {
432
    case REFERENCE_TYPE:
433
    case POINTER_TYPE:
434
      {
435
        /* Get the types-specifier of this type.  */
436
        tree pointee = strip_pointer_operator (TREE_TYPE (t));
437
        pp_c_specifier_qualifier_list (pp, pointee);
438
        if (TREE_CODE (pointee) == ARRAY_TYPE
439
            || TREE_CODE (pointee) == FUNCTION_TYPE)
440
          {
441
            pp_c_whitespace (pp);
442
            pp_c_left_paren (pp);
443
          }
444
        else if (!c_dialect_cxx ())
445
          pp_c_whitespace (pp);
446
        pp_ptr_operator (pp, t);
447
      }
448
      break;
449
 
450
    case FUNCTION_TYPE:
451
    case ARRAY_TYPE:
452
      pp_c_specifier_qualifier_list (pp, TREE_TYPE (t));
453
      break;
454
 
455
    case VECTOR_TYPE:
456
    case COMPLEX_TYPE:
457
      if (code == COMPLEX_TYPE)
458
        pp_c_ws_string (pp, flag_isoc99 ? "_Complex" : "__complex__");
459
      else if (code == VECTOR_TYPE)
460
        {
461
          pp_c_ws_string (pp, "__vector");
462
          pp_c_left_paren (pp);
463
          pp_wide_integer (pp, TYPE_VECTOR_SUBPARTS (t));
464
          pp_c_right_paren (pp);
465
          pp_c_whitespace (pp);
466
        }
467
      pp_c_specifier_qualifier_list (pp, TREE_TYPE (t));
468
      break;
469
 
470
    default:
471
      pp_simple_type_specifier (pp, t);
472
      break;
473
    }
474
}
475
 
476
/* parameter-type-list:
477
      parameter-list
478
      parameter-list , ...
479
 
480
   parameter-list:
481
      parameter-declaration
482
      parameter-list , parameter-declaration
483
 
484
   parameter-declaration:
485
      declaration-specifiers declarator
486
      declaration-specifiers abstract-declarator(opt)   */
487
 
488
void
489
pp_c_parameter_type_list (c_pretty_printer *pp, tree t)
490
{
491
  bool want_parm_decl = DECL_P (t) && !(pp->flags & pp_c_flag_abstract);
492
  tree parms = want_parm_decl ? DECL_ARGUMENTS (t) :  TYPE_ARG_TYPES (t);
493
  pp_c_left_paren (pp);
494
  if (parms == void_list_node)
495
    pp_c_ws_string (pp, "void");
496
  else
497
    {
498
      bool first = true;
499
      for ( ; parms && parms != void_list_node; parms = TREE_CHAIN (parms))
500
        {
501
          if (!first)
502
            pp_separate_with (pp, ',');
503
          first = false;
504
          pp_declaration_specifiers
505
            (pp, want_parm_decl ? parms : TREE_VALUE (parms));
506
          if (want_parm_decl)
507
            pp_declarator (pp, parms);
508
          else
509
            pp_abstract_declarator (pp, TREE_VALUE (parms));
510
        }
511
    }
512
  pp_c_right_paren (pp);
513
}
514
 
515
/* abstract-declarator:
516
      pointer
517
      pointer(opt) direct-abstract-declarator  */
518
 
519
static void
520
pp_c_abstract_declarator (c_pretty_printer *pp, tree t)
521
{
522
  if (TREE_CODE (t) == POINTER_TYPE)
523
    {
524
      if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
525
          || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
526
        pp_c_right_paren (pp);
527
      t = TREE_TYPE (t);
528
    }
529
 
530
  pp_direct_abstract_declarator (pp, t);
531
}
532
 
533
/* direct-abstract-declarator:
534
      ( abstract-declarator )
535
      direct-abstract-declarator(opt) [ assignment-expression(opt) ]
536
      direct-abstract-declarator(opt) [ * ]
537
      direct-abstract-declarator(opt) ( parameter-type-list(opt) )  */
538
 
539
void
540
pp_c_direct_abstract_declarator (c_pretty_printer *pp, tree t)
541
{
542
  switch (TREE_CODE (t))
543
    {
544
    case POINTER_TYPE:
545
      pp_abstract_declarator (pp, t);
546
      break;
547
 
548
    case FUNCTION_TYPE:
549
      pp_c_parameter_type_list (pp, t);
550
      pp_direct_abstract_declarator (pp, TREE_TYPE (t));
551
      break;
552
 
553
    case ARRAY_TYPE:
554
      pp_c_left_bracket (pp);
555
      if (TYPE_DOMAIN (t) && TYPE_MAX_VALUE (TYPE_DOMAIN (t)))
556
        {
557
          tree maxval = TYPE_MAX_VALUE (TYPE_DOMAIN (t));
558
          tree type = TREE_TYPE (maxval);
559
 
560
          if (host_integerp (maxval, 0))
561
            pp_wide_integer (pp, tree_low_cst (maxval, 0) + 1);
562
          else
563
            pp_expression (pp, fold_build2 (PLUS_EXPR, type, maxval,
564
                                            build_int_cst (type, 1)));
565
        }
566
      pp_c_right_bracket (pp);
567
      pp_direct_abstract_declarator (pp, TREE_TYPE (t));
568
      break;
569
 
570
    case IDENTIFIER_NODE:
571
    case VOID_TYPE:
572
    case BOOLEAN_TYPE:
573
    case INTEGER_TYPE:
574
    case REAL_TYPE:
575
    case FIXED_POINT_TYPE:
576
    case ENUMERAL_TYPE:
577
    case RECORD_TYPE:
578
    case UNION_TYPE:
579
    case VECTOR_TYPE:
580
    case COMPLEX_TYPE:
581
    case TYPE_DECL:
582
      break;
583
 
584
    default:
585
      pp_unsupported_tree (pp, t);
586
      break;
587
    }
588
}
589
 
590
/* type-name:
591
      specifier-qualifier-list  abstract-declarator(opt)  */
592
 
593
void
594
pp_c_type_id (c_pretty_printer *pp, tree t)
595
{
596
  pp_c_specifier_qualifier_list (pp, t);
597
  pp_abstract_declarator (pp, t);
598
}
599
 
600
/* storage-class-specifier:
601
      typedef
602
      extern
603
      static
604
      auto
605
      register  */
606
 
607
void
608
pp_c_storage_class_specifier (c_pretty_printer *pp, tree t)
609
{
610
  if (TREE_CODE (t) == TYPE_DECL)
611
    pp_c_ws_string (pp, "typedef");
612
  else if (DECL_P (t))
613
    {
614
      if (DECL_REGISTER (t))
615
        pp_c_ws_string (pp, "register");
616
      else if (TREE_STATIC (t) && TREE_CODE (t) == VAR_DECL)
617
        pp_c_ws_string (pp, "static");
618
    }
619
}
620
 
621
/* function-specifier:
622
      inline   */
623
 
624
void
625
pp_c_function_specifier (c_pretty_printer *pp, tree t)
626
{
627
  if (TREE_CODE (t) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (t))
628
    pp_c_ws_string (pp, "inline");
629
}
630
 
631
/* declaration-specifiers:
632
      storage-class-specifier declaration-specifiers(opt)
633
      type-specifier declaration-specifiers(opt)
634
      type-qualifier declaration-specifiers(opt)
635
      function-specifier declaration-specifiers(opt)  */
636
 
637
void
638
pp_c_declaration_specifiers (c_pretty_printer *pp, tree t)
639
{
640
  pp_storage_class_specifier (pp, t);
641
  pp_function_specifier (pp, t);
642
  pp_c_specifier_qualifier_list (pp, DECL_P (t) ?  TREE_TYPE (t) : t);
643
}
644
 
645
/* direct-declarator
646
      identifier
647
      ( declarator )
648
      direct-declarator [ type-qualifier-list(opt) assignment-expression(opt) ]
649
      direct-declarator [ static type-qualifier-list(opt) assignment-expression(opt)]
650
      direct-declarator [ type-qualifier-list static assignment-expression ]
651
      direct-declarator [ type-qualifier-list * ]
652
      direct-declarator ( parameter-type-list )
653
      direct-declarator ( identifier-list(opt) )  */
654
 
655
void
656
pp_c_direct_declarator (c_pretty_printer *pp, tree t)
657
{
658
  switch (TREE_CODE (t))
659
    {
660
    case VAR_DECL:
661
    case PARM_DECL:
662
    case TYPE_DECL:
663
    case FIELD_DECL:
664
    case LABEL_DECL:
665
      pp_c_space_for_pointer_operator (pp, TREE_TYPE (t));
666
      pp_c_tree_decl_identifier (pp, t);
667
      break;
668
 
669
    case ARRAY_TYPE:
670
    case POINTER_TYPE:
671
      pp_abstract_declarator (pp, TREE_TYPE (t));
672
      break;
673
 
674
    case FUNCTION_TYPE:
675
      pp_parameter_list (pp, t);
676
      pp_abstract_declarator (pp, TREE_TYPE (t));
677
      break;
678
 
679
    case FUNCTION_DECL:
680
      pp_c_space_for_pointer_operator (pp, TREE_TYPE (TREE_TYPE (t)));
681
      pp_c_tree_decl_identifier (pp, t);
682
      if (pp_c_base (pp)->flags & pp_c_flag_abstract)
683
        pp_abstract_declarator (pp, TREE_TYPE (t));
684
      else
685
        {
686
          pp_parameter_list (pp, t);
687
          pp_abstract_declarator (pp, TREE_TYPE (TREE_TYPE (t)));
688
        }
689
      break;
690
 
691
    case INTEGER_TYPE:
692
    case REAL_TYPE:
693
    case FIXED_POINT_TYPE:
694
    case ENUMERAL_TYPE:
695
    case UNION_TYPE:
696
    case RECORD_TYPE:
697
      break;
698
 
699
    default:
700
      pp_unsupported_tree (pp, t);
701
      break;
702
    }
703
}
704
 
705
 
706
/* declarator:
707
      pointer(opt)  direct-declarator   */
708
 
709
void
710
pp_c_declarator (c_pretty_printer *pp, tree t)
711
{
712
  switch (TREE_CODE (t))
713
    {
714
    case INTEGER_TYPE:
715
    case REAL_TYPE:
716
    case FIXED_POINT_TYPE:
717
    case ENUMERAL_TYPE:
718
    case UNION_TYPE:
719
    case RECORD_TYPE:
720
      break;
721
 
722
    case VAR_DECL:
723
    case PARM_DECL:
724
    case FIELD_DECL:
725
    case ARRAY_TYPE:
726
    case FUNCTION_TYPE:
727
    case FUNCTION_DECL:
728
    case TYPE_DECL:
729
      pp_direct_declarator (pp, t);
730
    break;
731
 
732
 
733
    default:
734
      pp_unsupported_tree (pp, t);
735
      break;
736
    }
737
}
738
 
739
/* declaration:
740
      declaration-specifiers init-declarator-list(opt) ;  */
741
 
742
void
743
pp_c_declaration (c_pretty_printer *pp, tree t)
744
{
745
  pp_declaration_specifiers (pp, t);
746
  pp_c_init_declarator (pp, t);
747
}
748
 
749
/* Pretty-print ATTRIBUTES using GNU C extension syntax.  */
750
 
751
void
752
pp_c_attributes (c_pretty_printer *pp, tree attributes)
753
{
754
  if (attributes == NULL_TREE)
755
    return;
756
 
757
  pp_c_ws_string (pp, "__attribute__");
758
  pp_c_left_paren (pp);
759
  pp_c_left_paren (pp);
760
  for (; attributes != NULL_TREE; attributes = TREE_CHAIN (attributes))
761
    {
762
      pp_tree_identifier (pp, TREE_PURPOSE (attributes));
763
      if (TREE_VALUE (attributes))
764
        pp_c_call_argument_list (pp, TREE_VALUE (attributes));
765
 
766
      if (TREE_CHAIN (attributes))
767
        pp_separate_with (pp, ',');
768
    }
769
  pp_c_right_paren (pp);
770
  pp_c_right_paren (pp);
771
}
772
 
773
/* function-definition:
774
      declaration-specifiers declarator compound-statement  */
775
 
776
void
777
pp_c_function_definition (c_pretty_printer *pp, tree t)
778
{
779
  pp_declaration_specifiers (pp, t);
780
  pp_declarator (pp, t);
781
  pp_needs_newline (pp) = true;
782
  pp_statement (pp, DECL_SAVED_TREE (t));
783
  pp_newline (pp);
784
  pp_flush (pp);
785
}
786
 
787
 
788
/* Expressions.  */
789
 
790
/* Print out a c-char.  This is called solely for characters which are
791
   in the *target* execution character set.  We ought to convert them
792
   back to the *host* execution character set before printing, but we
793
   have no way to do this at present.  A decent compromise is to print
794
   all characters as if they were in the host execution character set,
795
   and not attempt to recover any named escape characters, but render
796
   all unprintables as octal escapes.  If the host and target character
797
   sets are the same, this produces relatively readable output.  If they
798
   are not the same, strings may appear as gibberish, but that's okay
799
   (in fact, it may well be what the reader wants, e.g. if they are looking
800
   to see if conversion to the target character set happened correctly).
801
 
802
   A special case: we need to prefix \, ", and ' with backslashes.  It is
803
   correct to do so for the *host*'s \, ", and ', because the rest of the
804
   file appears in the host character set.  */
805
 
806
static void
807
pp_c_char (c_pretty_printer *pp, int c)
808
{
809
  if (ISPRINT (c))
810
    {
811
      switch (c)
812
        {
813
        case '\\': pp_string (pp, "\\\\"); break;
814
        case '\'': pp_string (pp, "\\\'"); break;
815
        case '\"': pp_string (pp, "\\\""); break;
816
        default:   pp_character (pp, c);
817
        }
818
    }
819
  else
820
    pp_scalar (pp, "\\%03o", (unsigned) c);
821
}
822
 
823
/* Print out a STRING literal.  */
824
 
825
void
826
pp_c_string_literal (c_pretty_printer *pp, tree s)
827
{
828
  const char *p = TREE_STRING_POINTER (s);
829
  int n = TREE_STRING_LENGTH (s) - 1;
830
  int i;
831
  pp_doublequote (pp);
832
  for (i = 0; i < n; ++i)
833
    pp_c_char (pp, p[i]);
834
  pp_doublequote (pp);
835
}
836
 
837
/* Pretty-print an INTEGER literal.  */
838
 
839
static void
840
pp_c_integer_constant (c_pretty_printer *pp, tree i)
841
{
842
  tree type = TREE_TYPE (i);
843
 
844
  if (TREE_INT_CST_HIGH (i) == 0)
845
    pp_wide_integer (pp, TREE_INT_CST_LOW (i));
846
  else
847
    {
848
      unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (i);
849
      HOST_WIDE_INT high = TREE_INT_CST_HIGH (i);
850
      if (tree_int_cst_sgn (i) < 0)
851
        {
852
          pp_character (pp, '-');
853
          high = ~high + !low;
854
          low = -low;
855
        }
856
      sprintf (pp_buffer (pp)->digit_buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
857
               (unsigned HOST_WIDE_INT) high, (unsigned HOST_WIDE_INT) low);
858
      pp_string (pp, pp_buffer (pp)->digit_buffer);
859
    }
860
  if (TYPE_UNSIGNED (type))
861
    pp_character (pp, 'u');
862
  if (type == long_integer_type_node || type == long_unsigned_type_node)
863
    pp_character (pp, 'l');
864
  else if (type == long_long_integer_type_node
865
           || type == long_long_unsigned_type_node)
866
    pp_string (pp, "ll");
867
}
868
 
869
/* Print out a CHARACTER literal.  */
870
 
871
static void
872
pp_c_character_constant (c_pretty_printer *pp, tree c)
873
{
874
  tree type = TREE_TYPE (c);
875
  if (type == wchar_type_node)
876
    pp_character (pp, 'L');
877
  pp_quote (pp);
878
  if (host_integerp (c, TYPE_UNSIGNED (type)))
879
    pp_c_char (pp, tree_low_cst (c, TYPE_UNSIGNED (type)));
880
  else
881
    pp_scalar (pp, "\\x%x", (unsigned) TREE_INT_CST_LOW (c));
882
  pp_quote (pp);
883
}
884
 
885
/* Print out a BOOLEAN literal.  */
886
 
887
static void
888
pp_c_bool_constant (c_pretty_printer *pp, tree b)
889
{
890
  if (b == boolean_false_node)
891
    {
892
      if (c_dialect_cxx ())
893
        pp_c_ws_string (pp, "false");
894
      else if (flag_isoc99)
895
        pp_c_ws_string (pp, "_False");
896
      else
897
        pp_unsupported_tree (pp, b);
898
    }
899
  else if (b == boolean_true_node)
900
    {
901
      if (c_dialect_cxx ())
902
        pp_c_ws_string (pp, "true");
903
      else if (flag_isoc99)
904
        pp_c_ws_string (pp, "_True");
905
      else
906
        pp_unsupported_tree (pp, b);
907
    }
908
  else if (TREE_CODE (b) == INTEGER_CST)
909
    pp_c_integer_constant (pp, b);
910
  else
911
    pp_unsupported_tree (pp, b);
912
}
913
 
914
/* Attempt to print out an ENUMERATOR.  Return true on success.  Else return
915
   false; that means the value was obtained by a cast, in which case
916
   print out the type-id part of the cast-expression -- the casted value
917
   is then printed by pp_c_integer_literal.  */
918
 
919
static bool
920
pp_c_enumeration_constant (c_pretty_printer *pp, tree e)
921
{
922
  bool value_is_named = true;
923
  tree type = TREE_TYPE (e);
924
  tree value;
925
 
926
  /* Find the name of this constant.  */
927
  for (value = TYPE_VALUES (type);
928
       value != NULL_TREE && !tree_int_cst_equal (TREE_VALUE (value), e);
929
       value = TREE_CHAIN (value))
930
    ;
931
 
932
  if (value != NULL_TREE)
933
    pp_id_expression (pp, TREE_PURPOSE (value));
934
  else
935
    {
936
      /* Value must have been cast.  */
937
      pp_c_type_cast (pp, type);
938
      value_is_named = false;
939
    }
940
 
941
  return value_is_named;
942
}
943
 
944
/* Print out a REAL value as a decimal-floating-constant.  */
945
 
946
static void
947
pp_c_floating_constant (c_pretty_printer *pp, tree r)
948
{
949
  real_to_decimal (pp_buffer (pp)->digit_buffer, &TREE_REAL_CST (r),
950
                   sizeof (pp_buffer (pp)->digit_buffer), 0, 1);
951
  pp_string (pp, pp_buffer(pp)->digit_buffer);
952
  if (TREE_TYPE (r) == float_type_node)
953
    pp_character (pp, 'f');
954
  else if (TREE_TYPE (r) == long_double_type_node)
955
    pp_character (pp, 'l');
956
  else if (TREE_TYPE (r) == dfloat128_type_node)
957
    pp_string (pp, "dl");
958
  else if (TREE_TYPE (r) == dfloat64_type_node)
959
    pp_string (pp, "dd");
960
  else if (TREE_TYPE (r) == dfloat32_type_node)
961
    pp_string (pp, "df");
962
}
963
 
964
/* Print out a FIXED value as a decimal-floating-constant.  */
965
 
966
static void
967
pp_c_fixed_constant (c_pretty_printer *pp, tree r)
968
{
969
  fixed_to_decimal (pp_buffer (pp)->digit_buffer, &TREE_FIXED_CST (r),
970
                   sizeof (pp_buffer (pp)->digit_buffer));
971
  pp_string (pp, pp_buffer(pp)->digit_buffer);
972
}
973
 
974
/* Pretty-print a compound literal expression.  GNU extensions include
975
   vector constants.  */
976
 
977
static void
978
pp_c_compound_literal (c_pretty_printer *pp, tree e)
979
{
980
  tree type = TREE_TYPE (e);
981
  pp_c_type_cast (pp, type);
982
 
983
  switch (TREE_CODE (type))
984
    {
985
    case RECORD_TYPE:
986
    case UNION_TYPE:
987
    case ARRAY_TYPE:
988
    case VECTOR_TYPE:
989
    case COMPLEX_TYPE:
990
      pp_c_brace_enclosed_initializer_list (pp, e);
991
      break;
992
 
993
    default:
994
      pp_unsupported_tree (pp, e);
995
      break;
996
    }
997
}
998
 
999
/* Pretty-print a COMPLEX_EXPR expression.  */
1000
 
1001
static void
1002
pp_c_complex_expr (c_pretty_printer *pp, tree e)
1003
{
1004
  /* Handle a few common special cases, otherwise fallback
1005
     to printing it as compound literal.  */
1006
  tree type = TREE_TYPE (e);
1007
  tree realexpr = TREE_OPERAND (e, 0);
1008
  tree imagexpr = TREE_OPERAND (e, 1);
1009
 
1010
  /* Cast of an COMPLEX_TYPE expression to a different COMPLEX_TYPE.  */
1011
  if (TREE_CODE (realexpr) == NOP_EXPR
1012
      && TREE_CODE (imagexpr) == NOP_EXPR
1013
      && TREE_TYPE (realexpr) == TREE_TYPE (type)
1014
      && TREE_TYPE (imagexpr) == TREE_TYPE (type)
1015
      && TREE_CODE (TREE_OPERAND (realexpr, 0)) == REALPART_EXPR
1016
      && TREE_CODE (TREE_OPERAND (imagexpr, 0)) == IMAGPART_EXPR
1017
      && TREE_OPERAND (TREE_OPERAND (realexpr, 0), 0)
1018
         == TREE_OPERAND (TREE_OPERAND (imagexpr, 0), 0))
1019
    {
1020
      pp_c_type_cast (pp, type);
1021
      pp_expression (pp, TREE_OPERAND (TREE_OPERAND (realexpr, 0), 0));
1022
      return;
1023
    }
1024
 
1025
  /* Cast of an scalar expression to COMPLEX_TYPE.  */
1026
  if ((integer_zerop (imagexpr) || real_zerop (imagexpr))
1027
      && TREE_TYPE (realexpr) == TREE_TYPE (type))
1028
    {
1029
      pp_c_type_cast (pp, type);
1030
      if (TREE_CODE (realexpr) == NOP_EXPR)
1031
        realexpr = TREE_OPERAND (realexpr, 0);
1032
      pp_expression (pp, realexpr);
1033
      return;
1034
    }
1035
 
1036
  pp_c_compound_literal (pp, e);
1037
}
1038
 
1039
/* constant:
1040
      integer-constant
1041
      floating-constant
1042
      fixed-point-constant
1043
      enumeration-constant
1044
      character-constant   */
1045
 
1046
void
1047
pp_c_constant (c_pretty_printer *pp, tree e)
1048
{
1049
  const enum tree_code code = TREE_CODE (e);
1050
 
1051
  switch (code)
1052
    {
1053
    case INTEGER_CST:
1054
      {
1055
        tree type = TREE_TYPE (e);
1056
        if (type == boolean_type_node)
1057
          pp_c_bool_constant (pp, e);
1058
        else if (type == char_type_node)
1059
          pp_c_character_constant (pp, e);
1060
        else if (TREE_CODE (type) == ENUMERAL_TYPE
1061
                 && pp_c_enumeration_constant (pp, e))
1062
          ;
1063
        else
1064
          pp_c_integer_constant (pp, e);
1065
      }
1066
      break;
1067
 
1068
    case REAL_CST:
1069
      pp_c_floating_constant (pp, e);
1070
      break;
1071
 
1072
    case FIXED_CST:
1073
      pp_c_fixed_constant (pp, e);
1074
      break;
1075
 
1076
    case STRING_CST:
1077
      pp_c_string_literal (pp, e);
1078
      break;
1079
 
1080
    case COMPLEX_CST:
1081
      /* Sometimes, we are confused and we think a complex literal
1082
         is a constant.  Such thing is a compound literal which
1083
         grammatically belongs to postfix-expr production.  */
1084
      pp_c_compound_literal (pp, e);
1085
      break;
1086
 
1087
    default:
1088
      pp_unsupported_tree (pp, e);
1089
      break;
1090
    }
1091
}
1092
 
1093
/* Pretty-print a string such as an identifier, without changing its
1094
   encoding, preceded by whitespace is necessary.  */
1095
 
1096
void
1097
pp_c_ws_string (c_pretty_printer *pp, const char *str)
1098
{
1099
  pp_c_maybe_whitespace (pp);
1100
  pp_string (pp, str);
1101
  pp_base (pp)->padding = pp_before;
1102
}
1103
 
1104
/* Pretty-print an IDENTIFIER_NODE, which may contain UTF-8 sequences
1105
   that need converting to the locale encoding, preceded by whitespace
1106
   is necessary.  */
1107
 
1108
void
1109
pp_c_identifier (c_pretty_printer *pp, const char *id)
1110
{
1111
  pp_c_maybe_whitespace (pp);
1112
  pp_identifier (pp, id);
1113
  pp_base (pp)->padding = pp_before;
1114
}
1115
 
1116
/* Pretty-print a C primary-expression.
1117
   primary-expression:
1118
      identifier
1119
      constant
1120
      string-literal
1121
      ( expression )   */
1122
 
1123
void
1124
pp_c_primary_expression (c_pretty_printer *pp, tree e)
1125
{
1126
  switch (TREE_CODE (e))
1127
    {
1128
    case VAR_DECL:
1129
    case PARM_DECL:
1130
    case FIELD_DECL:
1131
    case CONST_DECL:
1132
    case FUNCTION_DECL:
1133
    case LABEL_DECL:
1134
      pp_c_tree_decl_identifier (pp, e);
1135
      break;
1136
 
1137
    case IDENTIFIER_NODE:
1138
      pp_c_tree_identifier (pp, e);
1139
      break;
1140
 
1141
    case ERROR_MARK:
1142
      pp_c_ws_string (pp, M_("<erroneous-expression>"));
1143
      break;
1144
 
1145
    case RESULT_DECL:
1146
      pp_c_ws_string (pp, M_("<return-value>"));
1147
      break;
1148
 
1149
    case INTEGER_CST:
1150
    case REAL_CST:
1151
    case FIXED_CST:
1152
    case STRING_CST:
1153
      pp_c_constant (pp, e);
1154
      break;
1155
 
1156
    case TARGET_EXPR:
1157
      pp_c_ws_string (pp, "__builtin_memcpy");
1158
      pp_c_left_paren (pp);
1159
      pp_ampersand (pp);
1160
      pp_primary_expression (pp, TREE_OPERAND (e, 0));
1161
      pp_separate_with (pp, ',');
1162
      pp_ampersand (pp);
1163
      pp_initializer (pp, TREE_OPERAND (e, 1));
1164
      if (TREE_OPERAND (e, 2))
1165
        {
1166
          pp_separate_with (pp, ',');
1167
          pp_c_expression (pp, TREE_OPERAND (e, 2));
1168
        }
1169
      pp_c_right_paren (pp);
1170
      break;
1171
 
1172
    default:
1173
      /* FIXME:  Make sure we won't get into an infinite loop.  */
1174
      pp_c_left_paren (pp);
1175
      pp_expression (pp, e);
1176
      pp_c_right_paren (pp);
1177
      break;
1178
    }
1179
}
1180
 
1181
/* Print out a C initializer -- also support C compound-literals.
1182
   initializer:
1183
      assignment-expression:
1184
      { initializer-list }
1185
      { initializer-list , }   */
1186
 
1187
static void
1188
pp_c_initializer (c_pretty_printer *pp, tree e)
1189
{
1190
  if (TREE_CODE (e) == CONSTRUCTOR)
1191
    pp_c_brace_enclosed_initializer_list (pp, e);
1192
  else
1193
    pp_expression (pp, e);
1194
}
1195
 
1196
/* init-declarator:
1197
      declarator:
1198
      declarator = initializer   */
1199
 
1200
void
1201
pp_c_init_declarator (c_pretty_printer *pp, tree t)
1202
{
1203
  pp_declarator (pp, t);
1204
  /* We don't want to output function definitions here.  There are handled
1205
     elsewhere (and the syntactic form is bogus anyway).  */
1206
  if (TREE_CODE (t) != FUNCTION_DECL && DECL_INITIAL (t))
1207
    {
1208
      tree init = DECL_INITIAL (t);
1209
      /* This C++ bit is handled here because it is easier to do so.
1210
         In templates, the C++ parser builds a TREE_LIST for a
1211
         direct-initialization; the TREE_PURPOSE is the variable to
1212
         initialize and the TREE_VALUE is the initializer.  */
1213
      if (TREE_CODE (init) == TREE_LIST)
1214
        {
1215
          pp_c_left_paren (pp);
1216
          pp_expression (pp, TREE_VALUE (init));
1217
          pp_right_paren (pp);
1218
        }
1219
      else
1220
        {
1221
          pp_space (pp);
1222
          pp_equal (pp);
1223
          pp_space (pp);
1224
          pp_c_initializer (pp, init);
1225
        }
1226
    }
1227
}
1228
 
1229
/* initializer-list:
1230
      designation(opt) initializer
1231
      initializer-list , designation(opt) initializer
1232
 
1233
   designation:
1234
      designator-list =
1235
 
1236
   designator-list:
1237
      designator
1238
      designator-list designator
1239
 
1240
   designator:
1241
      [ constant-expression ]
1242
      identifier   */
1243
 
1244
static void
1245
pp_c_initializer_list (c_pretty_printer *pp, tree e)
1246
{
1247
  tree type = TREE_TYPE (e);
1248
  const enum tree_code code = TREE_CODE (type);
1249
 
1250
  if (TREE_CODE (e) == CONSTRUCTOR)
1251
    {
1252
      pp_c_constructor_elts (pp, CONSTRUCTOR_ELTS (e));
1253
      return;
1254
    }
1255
 
1256
  switch (code)
1257
    {
1258
    case RECORD_TYPE:
1259
    case UNION_TYPE:
1260
    case ARRAY_TYPE:
1261
      {
1262
        tree init = TREE_OPERAND (e, 0);
1263
        for (; init != NULL_TREE; init = TREE_CHAIN (init))
1264
          {
1265
            if (code == RECORD_TYPE || code == UNION_TYPE)
1266
              {
1267
                pp_c_dot (pp);
1268
                pp_c_primary_expression (pp, TREE_PURPOSE (init));
1269
              }
1270
            else
1271
              {
1272
                pp_c_left_bracket (pp);
1273
                if (TREE_PURPOSE (init))
1274
                  pp_c_constant (pp, TREE_PURPOSE (init));
1275
                pp_c_right_bracket (pp);
1276
              }
1277
            pp_c_whitespace (pp);
1278
            pp_equal (pp);
1279
            pp_c_whitespace (pp);
1280
            pp_initializer (pp, TREE_VALUE (init));
1281
            if (TREE_CHAIN (init))
1282
              pp_separate_with (pp, ',');
1283
          }
1284
      }
1285
      return;
1286
 
1287
    case VECTOR_TYPE:
1288
      if (TREE_CODE (e) == VECTOR_CST)
1289
        pp_c_expression_list (pp, TREE_VECTOR_CST_ELTS (e));
1290
      else
1291
        break;
1292
      return;
1293
 
1294
    case COMPLEX_TYPE:
1295
      if (TREE_CODE (e) == COMPLEX_CST || TREE_CODE (e) == COMPLEX_EXPR)
1296
        {
1297
          const bool cst = TREE_CODE (e) == COMPLEX_CST;
1298
          pp_expression (pp, cst ? TREE_REALPART (e) : TREE_OPERAND (e, 0));
1299
          pp_separate_with (pp, ',');
1300
          pp_expression (pp, cst ? TREE_IMAGPART (e) : TREE_OPERAND (e, 1));
1301
        }
1302
      else
1303
        break;
1304
      return;
1305
 
1306
    default:
1307
      break;
1308
    }
1309
 
1310
  pp_unsupported_tree (pp, type);
1311
}
1312
 
1313
/* Pretty-print a brace-enclosed initializer-list.  */
1314
 
1315
static void
1316
pp_c_brace_enclosed_initializer_list (c_pretty_printer *pp, tree l)
1317
{
1318
  pp_c_left_brace (pp);
1319
  pp_c_initializer_list (pp, l);
1320
  pp_c_right_brace (pp);
1321
}
1322
 
1323
 
1324
/*  This is a convenient function, used to bridge gap between C and C++
1325
    grammars.
1326
 
1327
    id-expression:
1328
       identifier  */
1329
 
1330
void
1331
pp_c_id_expression (c_pretty_printer *pp, tree t)
1332
{
1333
  switch (TREE_CODE (t))
1334
    {
1335
    case VAR_DECL:
1336
    case PARM_DECL:
1337
    case CONST_DECL:
1338
    case TYPE_DECL:
1339
    case FUNCTION_DECL:
1340
    case FIELD_DECL:
1341
    case LABEL_DECL:
1342
      pp_c_tree_decl_identifier (pp, t);
1343
      break;
1344
 
1345
    case IDENTIFIER_NODE:
1346
      pp_c_tree_identifier (pp, t);
1347
      break;
1348
 
1349
    default:
1350
      pp_unsupported_tree (pp, t);
1351
      break;
1352
    }
1353
}
1354
 
1355
/* postfix-expression:
1356
      primary-expression
1357
      postfix-expression [ expression ]
1358
      postfix-expression ( argument-expression-list(opt) )
1359
      postfix-expression . identifier
1360
      postfix-expression -> identifier
1361
      postfix-expression ++
1362
      postfix-expression --
1363
      ( type-name ) { initializer-list }
1364
      ( type-name ) { initializer-list , }  */
1365
 
1366
void
1367
pp_c_postfix_expression (c_pretty_printer *pp, tree e)
1368
{
1369
  enum tree_code code = TREE_CODE (e);
1370
  switch (code)
1371
    {
1372
    case POSTINCREMENT_EXPR:
1373
    case POSTDECREMENT_EXPR:
1374
      pp_postfix_expression (pp, TREE_OPERAND (e, 0));
1375
      pp_string (pp, code == POSTINCREMENT_EXPR ? "++" : "--");
1376
      break;
1377
 
1378
    case ARRAY_REF:
1379
      pp_postfix_expression (pp, TREE_OPERAND (e, 0));
1380
      pp_c_left_bracket (pp);
1381
      pp_expression (pp, TREE_OPERAND (e, 1));
1382
      pp_c_right_bracket (pp);
1383
      break;
1384
 
1385
    case CALL_EXPR:
1386
      {
1387
        call_expr_arg_iterator iter;
1388
        tree arg;
1389
        pp_postfix_expression (pp, CALL_EXPR_FN (e));
1390
        pp_c_left_paren (pp);
1391
        FOR_EACH_CALL_EXPR_ARG (arg, iter, e)
1392
          {
1393
            pp_expression (pp, arg);
1394
            if (more_call_expr_args_p (&iter))
1395
              pp_separate_with (pp, ',');
1396
          }
1397
        pp_c_right_paren (pp);
1398
        break;
1399
      }
1400
 
1401
    case UNORDERED_EXPR:
1402
      pp_c_ws_string (pp, flag_isoc99
1403
                           ? "isunordered"
1404
                           : "__builtin_isunordered");
1405
      goto two_args_fun;
1406
 
1407
    case ORDERED_EXPR:
1408
      pp_c_ws_string (pp, flag_isoc99
1409
                           ? "!isunordered"
1410
                           : "!__builtin_isunordered");
1411
      goto two_args_fun;
1412
 
1413
    case UNLT_EXPR:
1414
      pp_c_ws_string (pp, flag_isoc99
1415
                           ? "!isgreaterequal"
1416
                           : "!__builtin_isgreaterequal");
1417
      goto two_args_fun;
1418
 
1419
    case UNLE_EXPR:
1420
      pp_c_ws_string (pp, flag_isoc99
1421
                           ? "!isgreater"
1422
                           : "!__builtin_isgreater");
1423
      goto two_args_fun;
1424
 
1425
    case UNGT_EXPR:
1426
      pp_c_ws_string (pp, flag_isoc99
1427
                           ? "!islessequal"
1428
                           : "!__builtin_islessequal");
1429
      goto two_args_fun;
1430
 
1431
    case UNGE_EXPR:
1432
      pp_c_ws_string (pp, flag_isoc99
1433
                           ? "!isless"
1434
                           : "!__builtin_isless");
1435
      goto two_args_fun;
1436
 
1437
    case UNEQ_EXPR:
1438
      pp_c_ws_string (pp, flag_isoc99
1439
                           ? "!islessgreater"
1440
                           : "!__builtin_islessgreater");
1441
      goto two_args_fun;
1442
 
1443
    case LTGT_EXPR:
1444
      pp_c_ws_string (pp, flag_isoc99
1445
                           ? "islessgreater"
1446
                           : "__builtin_islessgreater");
1447
      goto two_args_fun;
1448
 
1449
    two_args_fun:
1450
      pp_c_left_paren (pp);
1451
      pp_expression (pp, TREE_OPERAND (e, 0));
1452
      pp_separate_with (pp, ',');
1453
      pp_expression (pp, TREE_OPERAND (e, 1));
1454
      pp_c_right_paren (pp);
1455
      break;
1456
 
1457
    case ABS_EXPR:
1458
      pp_c_ws_string (pp, "__builtin_abs");
1459
      pp_c_left_paren (pp);
1460
      pp_expression (pp, TREE_OPERAND (e, 0));
1461
      pp_c_right_paren (pp);
1462
      break;
1463
 
1464
    case COMPONENT_REF:
1465
      {
1466
        tree object = TREE_OPERAND (e, 0);
1467
        if (TREE_CODE (object) == INDIRECT_REF)
1468
          {
1469
            pp_postfix_expression (pp, TREE_OPERAND (object, 0));
1470
            pp_c_arrow (pp);
1471
          }
1472
        else
1473
          {
1474
            pp_postfix_expression (pp, object);
1475
            pp_c_dot (pp);
1476
          }
1477
        pp_expression (pp, TREE_OPERAND (e, 1));
1478
      }
1479
      break;
1480
 
1481
    case BIT_FIELD_REF:
1482
      {
1483
        tree type = TREE_TYPE (e);
1484
 
1485
        type = signed_or_unsigned_type_for (TYPE_UNSIGNED (type), type);
1486
        if (type
1487
            && tree_int_cst_equal (TYPE_SIZE (type), TREE_OPERAND (e, 1)))
1488
          {
1489
            HOST_WIDE_INT bitpos = tree_low_cst (TREE_OPERAND (e, 2), 0);
1490
            HOST_WIDE_INT size = tree_low_cst (TYPE_SIZE (type), 0);
1491
            if ((bitpos % size) == 0)
1492
              {
1493
                pp_c_left_paren (pp);
1494
                pp_c_left_paren (pp);
1495
                pp_type_id (pp, type);
1496
                pp_c_star (pp);
1497
                pp_c_right_paren (pp);
1498
                pp_c_ampersand (pp);
1499
                pp_expression (pp, TREE_OPERAND (e, 0));
1500
                pp_c_right_paren (pp);
1501
                pp_c_left_bracket (pp);
1502
                pp_wide_integer (pp, bitpos / size);
1503
                pp_c_right_bracket (pp);
1504
                break;
1505
              }
1506
          }
1507
        pp_unsupported_tree (pp, e);
1508
      }
1509
      break;
1510
 
1511
    case COMPLEX_CST:
1512
    case VECTOR_CST:
1513
      pp_c_compound_literal (pp, e);
1514
      break;
1515
 
1516
    case COMPLEX_EXPR:
1517
      pp_c_complex_expr (pp, e);
1518
      break;
1519
 
1520
    case COMPOUND_LITERAL_EXPR:
1521
      e = DECL_INITIAL (COMPOUND_LITERAL_EXPR_DECL (e));
1522
      /* Fall through.  */
1523
    case CONSTRUCTOR:
1524
      pp_initializer (pp, e);
1525
      break;
1526
 
1527
    case VA_ARG_EXPR:
1528
      pp_c_ws_string (pp, "__builtin_va_arg");
1529
      pp_c_left_paren (pp);
1530
      pp_assignment_expression (pp, TREE_OPERAND (e, 0));
1531
      pp_separate_with (pp, ',');
1532
      pp_type_id (pp, TREE_TYPE (e));
1533
      pp_c_right_paren (pp);
1534
      break;
1535
 
1536
    case ADDR_EXPR:
1537
      if (TREE_CODE (TREE_OPERAND (e, 0)) == FUNCTION_DECL)
1538
        {
1539
          pp_c_id_expression (pp, TREE_OPERAND (e, 0));
1540
          break;
1541
        }
1542
      /* else fall through.  */
1543
 
1544
    default:
1545
      pp_primary_expression (pp, e);
1546
      break;
1547
    }
1548
}
1549
 
1550
/* Print out an expression-list; E is expected to be a TREE_LIST.  */
1551
 
1552
void
1553
pp_c_expression_list (c_pretty_printer *pp, tree e)
1554
{
1555
  for (; e != NULL_TREE; e = TREE_CHAIN (e))
1556
    {
1557
      pp_expression (pp, TREE_VALUE (e));
1558
      if (TREE_CHAIN (e))
1559
        pp_separate_with (pp, ',');
1560
    }
1561
}
1562
 
1563
/* Print out V, which contains the elements of a constructor.  */
1564
 
1565
void
1566
pp_c_constructor_elts (c_pretty_printer *pp, VEC(constructor_elt,gc) *v)
1567
{
1568
  unsigned HOST_WIDE_INT ix;
1569
  tree value;
1570
 
1571
  FOR_EACH_CONSTRUCTOR_VALUE (v, ix, value)
1572
    {
1573
      pp_expression (pp, value);
1574
      if (ix != VEC_length (constructor_elt, v) - 1)
1575
        pp_separate_with (pp, ',');
1576
    }
1577
}
1578
 
1579
/* Print out an expression-list in parens, as if it were the argument
1580
   list to a function.  */
1581
 
1582
void
1583
pp_c_call_argument_list (c_pretty_printer *pp, tree t)
1584
{
1585
  pp_c_left_paren (pp);
1586
  if (t && TREE_CODE (t) == TREE_LIST)
1587
    pp_c_expression_list (pp, t);
1588
  pp_c_right_paren (pp);
1589
}
1590
 
1591
/* unary-expression:
1592
      postfix-expression
1593
      ++ cast-expression
1594
      -- cast-expression
1595
      unary-operator cast-expression
1596
      sizeof unary-expression
1597
      sizeof ( type-id )
1598
 
1599
  unary-operator: one of
1600
      * &  + - ! ~
1601
 
1602
   GNU extensions.
1603
   unary-expression:
1604
      __alignof__ unary-expression
1605
      __alignof__ ( type-id )
1606
      __real__ unary-expression
1607
      __imag__ unary-expression  */
1608
 
1609
void
1610
pp_c_unary_expression (c_pretty_printer *pp, tree e)
1611
{
1612
  enum tree_code code = TREE_CODE (e);
1613
  switch (code)
1614
    {
1615
    case PREINCREMENT_EXPR:
1616
    case PREDECREMENT_EXPR:
1617
      pp_string (pp, code == PREINCREMENT_EXPR ? "++" : "--");
1618
      pp_c_unary_expression (pp, TREE_OPERAND (e, 0));
1619
      break;
1620
 
1621
    case ADDR_EXPR:
1622
    case INDIRECT_REF:
1623
    case NEGATE_EXPR:
1624
    case BIT_NOT_EXPR:
1625
    case TRUTH_NOT_EXPR:
1626
    case CONJ_EXPR:
1627
      /* String literal are used by address.  */
1628
      if (code == ADDR_EXPR && TREE_CODE (TREE_OPERAND (e, 0)) != STRING_CST)
1629
        pp_ampersand (pp);
1630
      else if (code == INDIRECT_REF)
1631
        pp_c_star (pp);
1632
      else if (code == NEGATE_EXPR)
1633
        pp_minus (pp);
1634
      else if (code == BIT_NOT_EXPR || code == CONJ_EXPR)
1635
        pp_complement (pp);
1636
      else if (code == TRUTH_NOT_EXPR)
1637
        pp_exclamation (pp);
1638
      pp_c_cast_expression (pp, TREE_OPERAND (e, 0));
1639
      break;
1640
 
1641
    case REALPART_EXPR:
1642
    case IMAGPART_EXPR:
1643
      pp_c_ws_string (pp, code == REALPART_EXPR ? "__real__" : "__imag__");
1644
      pp_c_whitespace (pp);
1645
      pp_unary_expression (pp, TREE_OPERAND (e, 0));
1646
      break;
1647
 
1648
    default:
1649
      pp_postfix_expression (pp, e);
1650
      break;
1651
    }
1652
}
1653
 
1654
/* cast-expression:
1655
      unary-expression
1656
      ( type-name ) cast-expression  */
1657
 
1658
void
1659
pp_c_cast_expression (c_pretty_printer *pp, tree e)
1660
{
1661
  switch (TREE_CODE (e))
1662
    {
1663
    case FLOAT_EXPR:
1664
    case FIX_TRUNC_EXPR:
1665
    CASE_CONVERT:
1666
    case VIEW_CONVERT_EXPR:
1667
      pp_c_type_cast (pp, TREE_TYPE (e));
1668
      pp_c_cast_expression (pp, TREE_OPERAND (e, 0));
1669
      break;
1670
 
1671
    default:
1672
      pp_unary_expression (pp, e);
1673
    }
1674
}
1675
 
1676
/* multiplicative-expression:
1677
      cast-expression
1678
      multiplicative-expression * cast-expression
1679
      multiplicative-expression / cast-expression
1680
      multiplicative-expression % cast-expression   */
1681
 
1682
static void
1683
pp_c_multiplicative_expression (c_pretty_printer *pp, tree e)
1684
{
1685
  enum tree_code code = TREE_CODE (e);
1686
  switch (code)
1687
    {
1688
    case MULT_EXPR:
1689
    case TRUNC_DIV_EXPR:
1690
    case TRUNC_MOD_EXPR:
1691
      pp_multiplicative_expression (pp, TREE_OPERAND (e, 0));
1692
      pp_c_whitespace (pp);
1693
      if (code == MULT_EXPR)
1694
        pp_c_star (pp);
1695
      else if (code == TRUNC_DIV_EXPR)
1696
        pp_slash (pp);
1697
      else
1698
        pp_modulo (pp);
1699
      pp_c_whitespace (pp);
1700
      pp_c_cast_expression (pp, TREE_OPERAND (e, 1));
1701
      break;
1702
 
1703
    default:
1704
      pp_c_cast_expression (pp, e);
1705
      break;
1706
    }
1707
}
1708
 
1709
/* additive-expression:
1710
      multiplicative-expression
1711
      additive-expression + multiplicative-expression
1712
      additive-expression - multiplicative-expression   */
1713
 
1714
static void
1715
pp_c_additive_expression (c_pretty_printer *pp, tree e)
1716
{
1717
  enum tree_code code = TREE_CODE (e);
1718
  switch (code)
1719
    {
1720
    case POINTER_PLUS_EXPR:
1721
    case PLUS_EXPR:
1722
    case MINUS_EXPR:
1723
      pp_c_additive_expression (pp, TREE_OPERAND (e, 0));
1724
      pp_c_whitespace (pp);
1725
      if (code == PLUS_EXPR || code == POINTER_PLUS_EXPR)
1726
        pp_plus (pp);
1727
      else
1728
        pp_minus (pp);
1729
      pp_c_whitespace (pp);
1730
      pp_multiplicative_expression (pp, TREE_OPERAND (e, 1));
1731
      break;
1732
 
1733
    default:
1734
      pp_multiplicative_expression (pp, e);
1735
      break;
1736
    }
1737
}
1738
 
1739
/* additive-expression:
1740
      additive-expression
1741
      shift-expression << additive-expression
1742
      shift-expression >> additive-expression   */
1743
 
1744
static void
1745
pp_c_shift_expression (c_pretty_printer *pp, tree e)
1746
{
1747
  enum tree_code code = TREE_CODE (e);
1748
  switch (code)
1749
    {
1750
    case LSHIFT_EXPR:
1751
    case RSHIFT_EXPR:
1752
      pp_c_shift_expression (pp, TREE_OPERAND (e, 0));
1753
      pp_c_whitespace (pp);
1754
      pp_string (pp, code == LSHIFT_EXPR ? "<<" : ">>");
1755
      pp_c_whitespace (pp);
1756
      pp_c_additive_expression (pp, TREE_OPERAND (e, 1));
1757
      break;
1758
 
1759
    default:
1760
      pp_c_additive_expression (pp, e);
1761
    }
1762
}
1763
 
1764
/* relational-expression:
1765
      shift-expression
1766
      relational-expression < shift-expression
1767
      relational-expression > shift-expression
1768
      relational-expression <= shift-expression
1769
      relational-expression >= shift-expression   */
1770
 
1771
static void
1772
pp_c_relational_expression (c_pretty_printer *pp, tree e)
1773
{
1774
  enum tree_code code = TREE_CODE (e);
1775
  switch (code)
1776
    {
1777
    case LT_EXPR:
1778
    case GT_EXPR:
1779
    case LE_EXPR:
1780
    case GE_EXPR:
1781
      pp_c_relational_expression (pp, TREE_OPERAND (e, 0));
1782
      pp_c_whitespace (pp);
1783
      if (code == LT_EXPR)
1784
        pp_less (pp);
1785
      else if (code == GT_EXPR)
1786
        pp_greater (pp);
1787
      else if (code == LE_EXPR)
1788
        pp_string (pp, "<=");
1789
      else if (code == GE_EXPR)
1790
        pp_string (pp, ">=");
1791
      pp_c_whitespace (pp);
1792
      pp_c_shift_expression (pp, TREE_OPERAND (e, 1));
1793
      break;
1794
 
1795
    default:
1796
      pp_c_shift_expression (pp, e);
1797
      break;
1798
    }
1799
}
1800
 
1801
/* equality-expression:
1802
      relational-expression
1803
      equality-expression == relational-expression
1804
      equality-equality != relational-expression  */
1805
 
1806
static void
1807
pp_c_equality_expression (c_pretty_printer *pp, tree e)
1808
{
1809
  enum tree_code code = TREE_CODE (e);
1810
  switch (code)
1811
    {
1812
    case EQ_EXPR:
1813
    case NE_EXPR:
1814
      pp_c_equality_expression (pp, TREE_OPERAND (e, 0));
1815
      pp_c_whitespace (pp);
1816
      pp_string (pp, code == EQ_EXPR ? "==" : "!=");
1817
      pp_c_whitespace (pp);
1818
      pp_c_relational_expression (pp, TREE_OPERAND (e, 1));
1819
      break;
1820
 
1821
    default:
1822
      pp_c_relational_expression (pp, e);
1823
      break;
1824
    }
1825
}
1826
 
1827
/* AND-expression:
1828
      equality-expression
1829
      AND-expression & equality-equality   */
1830
 
1831
static void
1832
pp_c_and_expression (c_pretty_printer *pp, tree e)
1833
{
1834
  if (TREE_CODE (e) == BIT_AND_EXPR)
1835
    {
1836
      pp_c_and_expression (pp, TREE_OPERAND (e, 0));
1837
      pp_c_whitespace (pp);
1838
      pp_ampersand (pp);
1839
      pp_c_whitespace (pp);
1840
      pp_c_equality_expression (pp, TREE_OPERAND (e, 1));
1841
    }
1842
  else
1843
    pp_c_equality_expression (pp, e);
1844
}
1845
 
1846
/* exclusive-OR-expression:
1847
     AND-expression
1848
     exclusive-OR-expression ^ AND-expression  */
1849
 
1850
static void
1851
pp_c_exclusive_or_expression (c_pretty_printer *pp, tree e)
1852
{
1853
  if (TREE_CODE (e) == BIT_XOR_EXPR
1854
      || TREE_CODE (e) == TRUTH_XOR_EXPR)
1855
    {
1856
      pp_c_exclusive_or_expression (pp, TREE_OPERAND (e, 0));
1857
      if (TREE_CODE (e) == BIT_XOR_EXPR)
1858
        pp_c_maybe_whitespace (pp);
1859
      else
1860
        pp_c_whitespace (pp);
1861
      pp_carret (pp);
1862
      pp_c_whitespace (pp);
1863
      pp_c_and_expression (pp, TREE_OPERAND (e, 1));
1864
    }
1865
  else
1866
    pp_c_and_expression (pp, e);
1867
}
1868
 
1869
/* inclusive-OR-expression:
1870
     exclusive-OR-expression
1871
     inclusive-OR-expression | exclusive-OR-expression  */
1872
 
1873
static void
1874
pp_c_inclusive_or_expression (c_pretty_printer *pp, tree e)
1875
{
1876
  if (TREE_CODE (e) == BIT_IOR_EXPR)
1877
    {
1878
      pp_c_exclusive_or_expression (pp, TREE_OPERAND (e, 0));
1879
      pp_c_whitespace (pp);
1880
      pp_bar (pp);
1881
      pp_c_whitespace (pp);
1882
      pp_c_exclusive_or_expression (pp, TREE_OPERAND (e, 1));
1883
    }
1884
  else
1885
    pp_c_exclusive_or_expression (pp, e);
1886
}
1887
 
1888
/* logical-AND-expression:
1889
      inclusive-OR-expression
1890
      logical-AND-expression && inclusive-OR-expression  */
1891
 
1892
static void
1893
pp_c_logical_and_expression (c_pretty_printer *pp, tree e)
1894
{
1895
  if (TREE_CODE (e) == TRUTH_ANDIF_EXPR
1896
      || TREE_CODE (e) == TRUTH_AND_EXPR)
1897
    {
1898
      pp_c_logical_and_expression (pp, TREE_OPERAND (e, 0));
1899
      pp_c_whitespace (pp);
1900
      pp_string (pp, "&&");
1901
      pp_c_whitespace (pp);
1902
      pp_c_inclusive_or_expression (pp, TREE_OPERAND (e, 1));
1903
    }
1904
  else
1905
    pp_c_inclusive_or_expression (pp, e);
1906
}
1907
 
1908
/* logical-OR-expression:
1909
      logical-AND-expression
1910
      logical-OR-expression || logical-AND-expression  */
1911
 
1912
void
1913
pp_c_logical_or_expression (c_pretty_printer *pp, tree e)
1914
{
1915
  if (TREE_CODE (e) == TRUTH_ORIF_EXPR
1916
      || TREE_CODE (e) == TRUTH_OR_EXPR)
1917
    {
1918
      pp_c_logical_or_expression (pp, TREE_OPERAND (e, 0));
1919
      pp_c_whitespace (pp);
1920
      pp_string (pp, "||");
1921
      pp_c_whitespace (pp);
1922
      pp_c_logical_and_expression (pp, TREE_OPERAND (e, 1));
1923
    }
1924
  else
1925
    pp_c_logical_and_expression (pp, e);
1926
}
1927
 
1928
/* conditional-expression:
1929
      logical-OR-expression
1930
      logical-OR-expression ? expression : conditional-expression  */
1931
 
1932
static void
1933
pp_c_conditional_expression (c_pretty_printer *pp, tree e)
1934
{
1935
  if (TREE_CODE (e) == COND_EXPR)
1936
    {
1937
      pp_c_logical_or_expression (pp, TREE_OPERAND (e, 0));
1938
      pp_c_whitespace (pp);
1939
      pp_question (pp);
1940
      pp_c_whitespace (pp);
1941
      pp_expression (pp, TREE_OPERAND (e, 1));
1942
      pp_c_whitespace (pp);
1943
      pp_colon (pp);
1944
      pp_c_whitespace (pp);
1945
      pp_c_conditional_expression (pp, TREE_OPERAND (e, 2));
1946
    }
1947
  else
1948
    pp_c_logical_or_expression (pp, e);
1949
}
1950
 
1951
 
1952
/* assignment-expression:
1953
      conditional-expression
1954
      unary-expression assignment-operator  assignment-expression
1955
 
1956
   assignment-expression: one of
1957
      =    *=    /=    %=    +=    -=    >>=    <<=    &=    ^=    |=  */
1958
 
1959
static void
1960
pp_c_assignment_expression (c_pretty_printer *pp, tree e)
1961
{
1962
  if (TREE_CODE (e) == MODIFY_EXPR
1963
      || TREE_CODE (e) == INIT_EXPR)
1964
    {
1965
      pp_c_unary_expression (pp, TREE_OPERAND (e, 0));
1966
      pp_c_whitespace (pp);
1967
      pp_equal (pp);
1968
      pp_space (pp);
1969
      pp_c_expression (pp, TREE_OPERAND (e, 1));
1970
    }
1971
  else
1972
    pp_c_conditional_expression (pp, e);
1973
}
1974
 
1975
/* expression:
1976
       assignment-expression
1977
       expression , assignment-expression
1978
 
1979
  Implementation note:  instead of going through the usual recursion
1980
  chain, I take the liberty of dispatching nodes to the appropriate
1981
  functions.  This makes some redundancy, but it worths it. That also
1982
  prevents a possible infinite recursion between pp_c_primary_expression ()
1983
  and pp_c_expression ().  */
1984
 
1985
void
1986
pp_c_expression (c_pretty_printer *pp, tree e)
1987
{
1988
  switch (TREE_CODE (e))
1989
    {
1990
    case INTEGER_CST:
1991
      pp_c_integer_constant (pp, e);
1992
      break;
1993
 
1994
    case REAL_CST:
1995
      pp_c_floating_constant (pp, e);
1996
      break;
1997
 
1998
    case FIXED_CST:
1999
      pp_c_fixed_constant (pp, e);
2000
      break;
2001
 
2002
    case STRING_CST:
2003
      pp_c_string_literal (pp, e);
2004
      break;
2005
 
2006
    case IDENTIFIER_NODE:
2007
    case FUNCTION_DECL:
2008
    case VAR_DECL:
2009
    case CONST_DECL:
2010
    case PARM_DECL:
2011
    case RESULT_DECL:
2012
    case FIELD_DECL:
2013
    case LABEL_DECL:
2014
    case ERROR_MARK:
2015
      pp_primary_expression (pp, e);
2016
      break;
2017
 
2018
    case POSTINCREMENT_EXPR:
2019
    case POSTDECREMENT_EXPR:
2020
    case ARRAY_REF:
2021
    case CALL_EXPR:
2022
    case COMPONENT_REF:
2023
    case BIT_FIELD_REF:
2024
    case COMPLEX_CST:
2025
    case COMPLEX_EXPR:
2026
    case VECTOR_CST:
2027
    case ORDERED_EXPR:
2028
    case UNORDERED_EXPR:
2029
    case LTGT_EXPR:
2030
    case UNEQ_EXPR:
2031
    case UNLE_EXPR:
2032
    case UNLT_EXPR:
2033
    case UNGE_EXPR:
2034
    case UNGT_EXPR:
2035
    case ABS_EXPR:
2036
    case CONSTRUCTOR:
2037
    case COMPOUND_LITERAL_EXPR:
2038
    case VA_ARG_EXPR:
2039
      pp_postfix_expression (pp, e);
2040
      break;
2041
 
2042
    case CONJ_EXPR:
2043
    case ADDR_EXPR:
2044
    case INDIRECT_REF:
2045
    case NEGATE_EXPR:
2046
    case BIT_NOT_EXPR:
2047
    case TRUTH_NOT_EXPR:
2048
    case PREINCREMENT_EXPR:
2049
    case PREDECREMENT_EXPR:
2050
    case REALPART_EXPR:
2051
    case IMAGPART_EXPR:
2052
      pp_c_unary_expression (pp, e);
2053
      break;
2054
 
2055
    case FLOAT_EXPR:
2056
    case FIX_TRUNC_EXPR:
2057
    CASE_CONVERT:
2058
    case VIEW_CONVERT_EXPR:
2059
      pp_c_cast_expression (pp, e);
2060
      break;
2061
 
2062
    case MULT_EXPR:
2063
    case TRUNC_MOD_EXPR:
2064
    case TRUNC_DIV_EXPR:
2065
      pp_multiplicative_expression (pp, e);
2066
      break;
2067
 
2068
    case LSHIFT_EXPR:
2069
    case RSHIFT_EXPR:
2070
      pp_c_shift_expression (pp, e);
2071
      break;
2072
 
2073
    case LT_EXPR:
2074
    case GT_EXPR:
2075
    case LE_EXPR:
2076
    case GE_EXPR:
2077
      pp_c_relational_expression (pp, e);
2078
      break;
2079
 
2080
    case BIT_AND_EXPR:
2081
      pp_c_and_expression (pp, e);
2082
      break;
2083
 
2084
    case BIT_XOR_EXPR:
2085
    case TRUTH_XOR_EXPR:
2086
      pp_c_exclusive_or_expression (pp, e);
2087
      break;
2088
 
2089
    case BIT_IOR_EXPR:
2090
      pp_c_inclusive_or_expression (pp, e);
2091
      break;
2092
 
2093
    case TRUTH_ANDIF_EXPR:
2094
    case TRUTH_AND_EXPR:
2095
      pp_c_logical_and_expression (pp, e);
2096
      break;
2097
 
2098
    case TRUTH_ORIF_EXPR:
2099
    case TRUTH_OR_EXPR:
2100
      pp_c_logical_or_expression (pp, e);
2101
      break;
2102
 
2103
    case EQ_EXPR:
2104
    case NE_EXPR:
2105
      pp_c_equality_expression (pp, e);
2106
      break;
2107
 
2108
    case COND_EXPR:
2109
      pp_conditional_expression (pp, e);
2110
      break;
2111
 
2112
    case POINTER_PLUS_EXPR:
2113
    case PLUS_EXPR:
2114
    case MINUS_EXPR:
2115
      pp_c_additive_expression (pp, e);
2116
      break;
2117
 
2118
    case MODIFY_EXPR:
2119
    case INIT_EXPR:
2120
      pp_assignment_expression (pp, e);
2121
      break;
2122
 
2123
    case COMPOUND_EXPR:
2124
      pp_c_left_paren (pp);
2125
      pp_expression (pp, TREE_OPERAND (e, 0));
2126
      pp_separate_with (pp, ',');
2127
      pp_assignment_expression (pp, TREE_OPERAND (e, 1));
2128
      pp_c_right_paren (pp);
2129
      break;
2130
 
2131
    case NON_LVALUE_EXPR:
2132
    case SAVE_EXPR:
2133
      pp_expression (pp, TREE_OPERAND (e, 0));
2134
      break;
2135
 
2136
    case TARGET_EXPR:
2137
      pp_postfix_expression (pp, TREE_OPERAND (e, 1));
2138
      break;
2139
 
2140
    case BIND_EXPR:
2141
    case GOTO_EXPR:
2142
      /* We don't yet have a way of dumping statements in a
2143
         human-readable format.  */
2144
      pp_string (pp, "({...})");
2145
      break;
2146
 
2147
    default:
2148
      pp_unsupported_tree (pp, e);
2149
      break;
2150
    }
2151
}
2152
 
2153
 
2154
 
2155
/* Statements.  */
2156
 
2157
void
2158
pp_c_statement (c_pretty_printer *pp, tree stmt)
2159
{
2160
  if (stmt == NULL)
2161
    return;
2162
 
2163
  if (pp_needs_newline (pp))
2164
    pp_newline_and_indent (pp, 0);
2165
 
2166
  dump_generic_node (pp_base (pp), stmt, pp_indentation (pp), 0, true);
2167
}
2168
 
2169
 
2170
/* Initialize the PRETTY-PRINTER for handling C codes.  */
2171
 
2172
void
2173
pp_c_pretty_printer_init (c_pretty_printer *pp)
2174
{
2175
  pp->offset_list               = 0;
2176
 
2177
  pp->declaration               = pp_c_declaration;
2178
  pp->declaration_specifiers    = pp_c_declaration_specifiers;
2179
  pp->declarator                = pp_c_declarator;
2180
  pp->direct_declarator         = pp_c_direct_declarator;
2181
  pp->type_specifier_seq        = pp_c_specifier_qualifier_list;
2182
  pp->abstract_declarator       = pp_c_abstract_declarator;
2183
  pp->direct_abstract_declarator = pp_c_direct_abstract_declarator;
2184
  pp->ptr_operator              = pp_c_pointer;
2185
  pp->parameter_list            = pp_c_parameter_type_list;
2186
  pp->type_id                   = pp_c_type_id;
2187
  pp->simple_type_specifier     = pp_c_type_specifier;
2188
  pp->function_specifier        = pp_c_function_specifier;
2189
  pp->storage_class_specifier   = pp_c_storage_class_specifier;
2190
 
2191
  pp->statement                 = pp_c_statement;
2192
 
2193
  pp->constant                  = pp_c_constant;
2194
  pp->id_expression             = pp_c_id_expression;
2195
  pp->primary_expression        = pp_c_primary_expression;
2196
  pp->postfix_expression        = pp_c_postfix_expression;
2197
  pp->unary_expression          = pp_c_unary_expression;
2198
  pp->initializer               = pp_c_initializer;
2199
  pp->multiplicative_expression = pp_c_multiplicative_expression;
2200
  pp->conditional_expression    = pp_c_conditional_expression;
2201
  pp->assignment_expression     = pp_c_assignment_expression;
2202
  pp->expression                = pp_c_expression;
2203
}
2204
 
2205
 
2206
/* Print the tree T in full, on file FILE.  */
2207
 
2208
void
2209
print_c_tree (FILE *file, tree t)
2210
{
2211
  static c_pretty_printer pp_rec;
2212
  static bool initialized = 0;
2213
  c_pretty_printer *pp = &pp_rec;
2214
 
2215
  if (!initialized)
2216
    {
2217
      initialized = 1;
2218
      pp_construct (pp_base (pp), NULL, 0);
2219
      pp_c_pretty_printer_init (pp);
2220
      pp_needs_newline (pp) = true;
2221
    }
2222
  pp_base (pp)->buffer->stream = file;
2223
 
2224
  pp_statement (pp, t);
2225
 
2226
  pp_newline (pp);
2227
  pp_flush (pp);
2228
}
2229
 
2230
/* Print the tree T in full, on stderr.  */
2231
 
2232
void
2233
debug_c_tree (tree t)
2234
{
2235
  print_c_tree (stderr, t);
2236
  fputc ('\n', stderr);
2237
}
2238
 
2239
/* Output the DECL_NAME of T.  If T has no DECL_NAME, output a string made
2240
   up of T's memory address.  */
2241
 
2242
void
2243
pp_c_tree_decl_identifier (c_pretty_printer *pp, tree t)
2244
{
2245
  const char *name;
2246
 
2247
  gcc_assert (DECL_P (t));
2248
 
2249
  if (DECL_NAME (t))
2250
    name = IDENTIFIER_POINTER (DECL_NAME (t));
2251
  else
2252
    {
2253
      static char xname[8];
2254
      sprintf (xname, "<U%4x>", ((unsigned)((uintptr_t)(t) & 0xffff)));
2255
      name = xname;
2256
    }
2257
 
2258
  pp_c_identifier (pp, name);
2259
}

powered by: WebSVN 2.1.0

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