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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gcc-4.5.1/] [gcc/] [ada/] [styleg.adb] - Blame information for rev 826

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 281 jeremybenn
------------------------------------------------------------------------------
2
--                                                                          --
3
--                         GNAT COMPILER COMPONENTS                         --
4
--                                                                          --
5
--                               S T Y L E G                                --
6
--                                                                          --
7
--                                 B o d y                                  --
8
--                                                                          --
9
--          Copyright (C) 1992-2009, Free Software Foundation, Inc.         --
10
--                                                                          --
11
-- GNAT is free software;  you can  redistribute it  and/or modify it under --
12
-- terms of the  GNU General Public License as published  by the Free Soft- --
13
-- ware  Foundation;  either version 3,  or (at your option) any later ver- --
14
-- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
15
-- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
16
-- or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License --
17
-- for  more details.  You should have  received  a copy of the GNU General --
18
-- Public License  distributed with GNAT; see file COPYING3.  If not, go to --
19
-- http://www.gnu.org/licenses for a complete copy of the license.          --
20
--                                                                          --
21
-- GNAT was originally developed  by the GNAT team at  New York University. --
22
-- Extensive contributions were provided by Ada Core Technologies Inc.      --
23
--                                                                          --
24
------------------------------------------------------------------------------
25
 
26
--  This version of the Style package implements the standard GNAT style
27
--  checking rules. For documentation of these rules, see comments on the
28
--  individual procedures.
29
 
30
with Atree;    use Atree;
31
with Casing;   use Casing;
32
with Csets;    use Csets;
33
with Einfo;    use Einfo;
34
with Err_Vars; use Err_Vars;
35
with Opt;      use Opt;
36
with Scans;    use Scans;
37
with Sinfo;    use Sinfo;
38
with Sinput;   use Sinput;
39
with Stylesw;  use Stylesw;
40
 
41
package body Styleg is
42
 
43
   use ASCII;
44
 
45
   Blank_Lines : Nat := 0;
46
   --  Counts number of empty lines seen. Reset to zero if a non-empty line
47
   --  is encountered. Used to check for trailing blank lines in Check_EOF,
48
   --  and for multiple blank lines.
49
 
50
   Blank_Line_Location : Source_Ptr;
51
   --  Remembers location of first blank line in a series. Used to issue an
52
   --  appropriate diagnostic if subsequent blank lines or the end of file
53
   --  is encountered.
54
 
55
   -----------------------
56
   -- Local Subprograms --
57
   -----------------------
58
 
59
   procedure Check_No_Space_After;
60
   --  Checks that there is a non-white space character after the current
61
   --  token, or white space followed by a comment, or the end of line.
62
   --  Issue error message if not.
63
 
64
   procedure Check_No_Space_Before;
65
   --  Check that token is first token on line, or else is not preceded
66
   --  by white space. Signal error of space not allowed if not.
67
 
68
   procedure Check_Separate_Stmt_Lines_Cont;
69
   --  Non-inlined continuation of Check_Separate_Stmt_Lines
70
 
71
   function Determine_Token_Casing return Casing_Type;
72
   --  Determine casing of current token
73
 
74
   procedure Error_Space_Not_Allowed (S : Source_Ptr);
75
   --  Posts an error message indicating that a space is not allowed
76
   --  at the given source location.
77
 
78
   procedure Error_Space_Required (S : Source_Ptr);
79
   --  Posts an error message indicating that a space is required at
80
   --  the given source location.
81
 
82
   function Is_White_Space (C : Character) return Boolean;
83
   pragma Inline (Is_White_Space);
84
   --  Returns True for space, HT, VT or FF, False otherwise
85
 
86
   procedure Require_Following_Space;
87
   pragma Inline (Require_Following_Space);
88
   --  Require token to be followed by white space. Used only if in GNAT
89
   --  style checking mode.
90
 
91
   procedure Require_Preceding_Space;
92
   pragma Inline (Require_Preceding_Space);
93
   --  Require token to be preceded by white space. Used only if in GNAT
94
   --  style checking mode.
95
 
96
   ----------------------
97
   -- Check_Abs_Or_Not --
98
   ----------------------
99
 
100
   --  In check tokens mode (-gnatyt), ABS/NOT must be followed by a space
101
 
102
   procedure Check_Abs_Not is
103
   begin
104
      if Style_Check_Tokens then
105
         if Source (Scan_Ptr) > ' ' then
106
            Error_Space_Required (Scan_Ptr);
107
         end if;
108
      end if;
109
   end Check_Abs_Not;
110
 
111
   ----------------------
112
   -- Check_Apostrophe --
113
   ----------------------
114
 
115
   --  Do not allow space before or after apostrophe
116
 
117
   procedure Check_Apostrophe is
118
   begin
119
      if Style_Check_Tokens then
120
         Check_No_Space_After;
121
      end if;
122
   end Check_Apostrophe;
123
 
124
   -----------------
125
   -- Check_Arrow --
126
   -----------------
127
 
128
   --  In check tokens mode (-gnatys), arrow must be surrounded by spaces
129
 
130
   procedure Check_Arrow is
131
   begin
132
      if Style_Check_Tokens then
133
         Require_Preceding_Space;
134
         Require_Following_Space;
135
      end if;
136
   end Check_Arrow;
137
 
138
   --------------------------
139
   -- Check_Attribute_Name --
140
   --------------------------
141
 
142
   --  In check attribute casing mode (-gnatya), attribute names must be
143
   --  mixed case, i.e. start with an upper case letter, and otherwise
144
   --  lower case, except after an underline character.
145
 
146
   procedure Check_Attribute_Name (Reserved : Boolean) is
147
      pragma Warnings (Off, Reserved);
148
   begin
149
      if Style_Check_Attribute_Casing then
150
         if Determine_Token_Casing /= Mixed_Case then
151
            Error_Msg_SC -- CODEFIX
152
              ("(style) bad capitalization, mixed case required");
153
         end if;
154
      end if;
155
   end Check_Attribute_Name;
156
 
157
   ---------------------------
158
   -- Check_Binary_Operator --
159
   ---------------------------
160
 
161
   --  In check token mode (-gnatyt), binary operators other than the special
162
   --  case of exponentiation require surrounding space characters.
163
 
164
   procedure Check_Binary_Operator is
165
   begin
166
      if Style_Check_Tokens then
167
         Require_Preceding_Space;
168
         Require_Following_Space;
169
      end if;
170
   end Check_Binary_Operator;
171
 
172
   ----------------------------
173
   -- Check_Boolean_Operator --
174
   ----------------------------
175
 
176
   procedure Check_Boolean_Operator (Node : Node_Id) is
177
 
178
      function OK_Boolean_Operand (N : Node_Id) return Boolean;
179
      --  Returns True for simple variable, or "not X1" or "X1 and X2" or
180
      --  "X1 or X2" where X1, X2 are recursively OK_Boolean_Operand's.
181
 
182
      ------------------------
183
      -- OK_Boolean_Operand --
184
      ------------------------
185
 
186
      function OK_Boolean_Operand (N : Node_Id) return Boolean is
187
      begin
188
         if Nkind_In (N, N_Identifier, N_Expanded_Name) then
189
            return True;
190
 
191
         elsif Nkind (N) = N_Op_Not then
192
            return OK_Boolean_Operand (Original_Node (Right_Opnd (N)));
193
 
194
         elsif Nkind_In (N, N_Op_And, N_Op_Or) then
195
            return OK_Boolean_Operand (Original_Node (Left_Opnd (N)))
196
                     and then
197
                   OK_Boolean_Operand (Original_Node (Right_Opnd (N)));
198
 
199
         else
200
            return False;
201
         end if;
202
      end OK_Boolean_Operand;
203
 
204
   --  Start of processig for Check_Boolean_Operator
205
   begin
206
      if Style_Check_Boolean_And_Or
207
        and then Comes_From_Source (Node)
208
      then
209
         declare
210
            Orig : constant Node_Id := Original_Node (Node);
211
 
212
         begin
213
            if Nkind_In (Orig, N_Op_And, N_Op_Or) then
214
               declare
215
                  L : constant Node_Id := Original_Node (Left_Opnd  (Orig));
216
                  R : constant Node_Id := Original_Node (Right_Opnd (Orig));
217
 
218
               begin
219
                  --  First OK case, simple boolean constants/identifiers
220
 
221
                  if OK_Boolean_Operand (L)
222
                       and then
223
                     OK_Boolean_Operand (R)
224
                  then
225
                     return;
226
 
227
                  --  Second OK case, modular types
228
 
229
                  elsif Is_Modular_Integer_Type (Etype (Node)) then
230
                     return;
231
 
232
                  --  Third OK case, array types
233
 
234
                  elsif Is_Array_Type (Etype (Node)) then
235
                     return;
236
 
237
                  --  Otherwise we have an error
238
 
239
                  elsif Nkind (Orig) = N_Op_And then
240
                     Error_Msg ("(style) `AND THEN` required", Sloc (Orig));
241
                  else
242
                     Error_Msg ("(style) `OR ELSE` required", Sloc (Orig));
243
                  end if;
244
               end;
245
            end if;
246
         end;
247
      end if;
248
   end Check_Boolean_Operator;
249
 
250
   ---------------
251
   -- Check_Box --
252
   ---------------
253
 
254
   --  In check token mode (-gnatyt), box must be preceded by a space or by
255
   --  a left parenthesis. Spacing checking on the surrounding tokens takes
256
   --  care of the remaining checks.
257
 
258
   procedure Check_Box is
259
   begin
260
      if Style_Check_Tokens then
261
         if Prev_Token /= Tok_Left_Paren then
262
            Require_Preceding_Space;
263
         end if;
264
      end if;
265
   end Check_Box;
266
 
267
   -----------------
268
   -- Check_Colon --
269
   -----------------
270
 
271
   --  In check token mode (-gnatyt), colon must be surrounded by spaces
272
 
273
   procedure Check_Colon is
274
   begin
275
      if Style_Check_Tokens then
276
         Require_Preceding_Space;
277
         Require_Following_Space;
278
      end if;
279
   end Check_Colon;
280
 
281
   -----------------------
282
   -- Check_Colon_Equal --
283
   -----------------------
284
 
285
   --  In check token mode (-gnatyt), := must be surrounded by spaces
286
 
287
   procedure Check_Colon_Equal is
288
   begin
289
      if Style_Check_Tokens then
290
         Require_Preceding_Space;
291
         Require_Following_Space;
292
      end if;
293
   end Check_Colon_Equal;
294
 
295
   -----------------
296
   -- Check_Comma --
297
   -----------------
298
 
299
   --  In check token mode (-gnatyt), comma must be either the first
300
   --  token on a line, or be preceded by a non-blank character.
301
   --  It must also always be followed by a blank.
302
 
303
   procedure Check_Comma is
304
   begin
305
      if Style_Check_Tokens then
306
         Check_No_Space_Before;
307
 
308
         if Source (Scan_Ptr) > ' ' then
309
            Error_Space_Required (Scan_Ptr);
310
         end if;
311
      end if;
312
   end Check_Comma;
313
 
314
   -------------------
315
   -- Check_Comment --
316
   -------------------
317
 
318
   --  In check comment mode (-gnatyc) there are several requirements on the
319
   --  format of comments. The following are permissible comment formats:
320
 
321
   --    1. Any comment that is not at the start of a line, i.e. where the
322
   --       initial minuses are not the first non-blank characters on the
323
   --       line must have at least one blank after the second minus or a
324
   --       special character as defined in rule 5.
325
 
326
   --    2. A row of all minuses of any length is permitted (see procedure
327
   --       box above in the source of this routine).
328
 
329
   --    3. A comment line starting with two minuses and a space, and ending
330
   --       with a space and two minuses. Again see the procedure title box
331
   --       immediately above in the source.
332
 
333
   --    4. A full line comment where two spaces follow the two minus signs.
334
   --       This is the normal comment format in GNAT style, as typified by
335
   --       the comments you are reading now.
336
 
337
   --    5. A full line comment where the first character after the second
338
   --       minus is a special character, i.e. a character in the ASCII
339
   --       range 16#21#..16#2F# or 16#3A#..16#3F#. This allows special
340
   --       comments, such as those generated by gnatprep, or those that
341
   --       appear in the SPARK annotation language to be accepted.
342
 
343
   --       Note: for GNAT internal files (-gnatg switch set on for the
344
   --       compilation), the only special sequence recognized and allowed
345
   --       is --! as generated by gnatprep.
346
 
347
   --    6. In addition, the comment must be properly indented if comment
348
   --       indentation checking is active (Style_Check_Indentation non-zero).
349
   --       Either the start column must be a multiple of this indentation,
350
   --       or the indentation must match that of the next non-blank line.
351
 
352
   procedure Check_Comment is
353
      S : Source_Ptr;
354
      C : Character;
355
 
356
      function Is_Box_Comment return Boolean;
357
      --  Returns True if the last two characters on the line are -- which
358
      --  characterizes a box comment (as for example follows this spec).
359
 
360
      function Is_Special_Character (C : Character) return Boolean;
361
      --  Determines if C is a special character (see rule 5 above)
362
 
363
      function Same_Column_As_Next_Non_Blank_Line return Boolean;
364
      --  Called for a full line comment. If the indentation of this comment
365
      --  matches that of the next non-blank line in the source, then True is
366
      --  returned, otherwise False.
367
 
368
      --------------------
369
      -- Is_Box_Comment --
370
      --------------------
371
 
372
      function Is_Box_Comment return Boolean is
373
         S : Source_Ptr;
374
 
375
      begin
376
         --  Do we need to worry about UTF_32 line terminators here ???
377
 
378
         S := Scan_Ptr + 3;
379
         while Source (S) not in Line_Terminator loop
380
            S := S + 1;
381
         end loop;
382
 
383
         return Source (S - 1) = '-' and then Source (S - 2) = '-';
384
      end Is_Box_Comment;
385
 
386
      --------------------------
387
      -- Is_Special_Character --
388
      --------------------------
389
 
390
      function Is_Special_Character (C : Character) return Boolean is
391
      begin
392
         if GNAT_Mode then
393
            return C = '!';
394
         else
395
            return
396
              Character'Pos (C) in 16#21# .. 16#2F#
397
                or else
398
              Character'Pos (C) in 16#3A# .. 16#3F#;
399
         end if;
400
      end Is_Special_Character;
401
 
402
      ----------------------------------------
403
      -- Same_Column_As_Next_Non_Blank_Line --
404
      ----------------------------------------
405
 
406
      function Same_Column_As_Next_Non_Blank_Line return Boolean is
407
         P : Source_Ptr;
408
 
409
      begin
410
         --  Step to end of line
411
 
412
         P := Scan_Ptr + 2;
413
         while Source (P) not in Line_Terminator loop
414
            P := P + 1;
415
         end loop;
416
 
417
         --  Step past blanks, and line terminators (UTF_32 case???)
418
 
419
         while Source (P) <= ' ' and then Source (P) /= EOF loop
420
            P := P + 1;
421
         end loop;
422
 
423
         --  Compare columns
424
 
425
         return Get_Column_Number (Scan_Ptr) = Get_Column_Number (P);
426
      end Same_Column_As_Next_Non_Blank_Line;
427
 
428
   --  Start of processing for Check_Comment
429
 
430
   begin
431
      --  Can never have a non-blank character preceding the first minus
432
 
433
      if Style_Check_Comments then
434
         if Scan_Ptr > Source_First (Current_Source_File)
435
           and then Source (Scan_Ptr - 1) > ' '
436
         then
437
            Error_Msg_S ("(style) space required");
438
         end if;
439
      end if;
440
 
441
      --  For a comment that is not at the start of the line, the only
442
      --  requirement is that we cannot have a non-blank character after
443
      --  the second minus sign or a special character.
444
 
445
      if Scan_Ptr /= First_Non_Blank_Location then
446
         if Style_Check_Comments then
447
            if Source (Scan_Ptr + 2) > ' '
448
              and then not Is_Special_Character (Source (Scan_Ptr + 2))
449
            then
450
               Error_Msg ("(style) space required", Scan_Ptr + 2);
451
            end if;
452
         end if;
453
 
454
         return;
455
 
456
      --  Case of a comment that is at the start of a line
457
 
458
      else
459
         --  First check, must be in appropriately indented column
460
 
461
         if Style_Check_Indentation /= 0 then
462
            if Start_Column rem Style_Check_Indentation /= 0 then
463
               if not Same_Column_As_Next_Non_Blank_Line then
464
                  Error_Msg_S -- CODEFIX
465
                    ("(style) bad column");
466
               end if;
467
 
468
               return;
469
            end if;
470
         end if;
471
 
472
         --  If we are not checking comments, nothing more to do
473
 
474
         if not Style_Check_Comments then
475
            return;
476
         end if;
477
 
478
         --  Case of not followed by a blank. Usually wrong, but there are
479
         --  some exceptions that we permit.
480
 
481
         if Source (Scan_Ptr + 2) /= ' ' then
482
            C := Source (Scan_Ptr + 2);
483
 
484
            --  Case of -- all on its own on a line is OK
485
 
486
            if C < ' ' then
487
               return;
488
            end if;
489
 
490
            --  Case of --x, x special character is OK (gnatprep/SPARK/etc.)
491
            --  This is not permitted in internal GNAT implementation units
492
            --  except for the case of --! as used by gnatprep output.
493
 
494
            if Is_Special_Character (C) then
495
               return;
496
            end if;
497
 
498
            --  The only other case in which we allow a character after
499
            --  the -- other than a space is when we have a row of minus
500
            --  signs (case of header lines for a box comment for example).
501
 
502
            S := Scan_Ptr + 2;
503
            while Source (S) >= ' ' loop
504
               if Source (S) /= '-' then
505
                  if Is_Box_Comment then
506
                     Error_Space_Required (Scan_Ptr + 2);
507
                  else
508
                     Error_Msg ("(style) two spaces required", Scan_Ptr + 2);
509
                  end if;
510
 
511
                  return;
512
               end if;
513
 
514
               S := S + 1;
515
            end loop;
516
 
517
         --  If we are followed by a blank, then the comment is OK if the
518
         --  character following this blank is another blank or a format
519
         --  effector.
520
 
521
         elsif Source (Scan_Ptr + 3) <= ' ' then
522
            return;
523
 
524
         --  Here is the case where we only have one blank after the two
525
         --  minus signs, which is an error unless the line ends with two
526
         --  minus signs, the case of a box comment.
527
 
528
         elsif not Is_Box_Comment then
529
            Error_Space_Required (Scan_Ptr + 3);
530
         end if;
531
      end if;
532
   end Check_Comment;
533
 
534
   -------------------
535
   -- Check_Dot_Dot --
536
   -------------------
537
 
538
   --  In check token mode (-gnatyt), colon must be surrounded by spaces
539
 
540
   procedure Check_Dot_Dot is
541
   begin
542
      if Style_Check_Tokens then
543
         Require_Preceding_Space;
544
         Require_Following_Space;
545
      end if;
546
   end Check_Dot_Dot;
547
 
548
   ---------------
549
   -- Check_EOF --
550
   ---------------
551
 
552
   --  In check blanks at end mode, check no blank lines precede the EOF
553
 
554
   procedure Check_EOF is
555
   begin
556
      if Style_Check_Blank_Lines then
557
 
558
         --  We expect one blank line, from the EOF, but no more than one
559
 
560
         if Blank_Lines = 2 then
561
            Error_Msg
562
              ("(style) blank line not allowed at end of file",
563
               Blank_Line_Location);
564
 
565
         elsif Blank_Lines >= 3 then
566
            Error_Msg
567
              ("(style) blank lines not allowed at end of file",
568
               Blank_Line_Location);
569
         end if;
570
      end if;
571
   end Check_EOF;
572
 
573
   -----------------------------------
574
   -- Check_Exponentiation_Operator --
575
   -----------------------------------
576
 
577
   --  No spaces are required for the ** operator in GNAT style check mode
578
 
579
   procedure Check_Exponentiation_Operator is
580
   begin
581
      null;
582
   end Check_Exponentiation_Operator;
583
 
584
   --------------
585
   -- Check_HT --
586
   --------------
587
 
588
   --  In check horizontal tab mode (-gnatyh), tab characters are not allowed
589
 
590
   procedure Check_HT is
591
   begin
592
      if Style_Check_Horizontal_Tabs then
593
         Error_Msg_S ("(style) horizontal tab not allowed");
594
      end if;
595
   end Check_HT;
596
 
597
   -----------------------
598
   -- Check_Indentation --
599
   -----------------------
600
 
601
   --  In check indentation mode (-gnatyn for n a digit), a new statement or
602
   --  declaration is required to start in a column that is a multiple of the
603
   --  indentation amount.
604
 
605
   procedure Check_Indentation is
606
   begin
607
      if Style_Check_Indentation /= 0 then
608
         if Token_Ptr = First_Non_Blank_Location
609
           and then Start_Column rem Style_Check_Indentation /= 0
610
         then
611
            Error_Msg_SC ("(style) bad indentation");
612
         end if;
613
      end if;
614
   end Check_Indentation;
615
 
616
   ----------------------
617
   -- Check_Left_Paren --
618
   ----------------------
619
 
620
   --  In tone check mode (-gnatyt), left paren must not be preceded by an
621
   --  identifier character or digit (a separating space is required) and
622
   --  may never be followed by a space.
623
 
624
   procedure Check_Left_Paren is
625
   begin
626
      if Style_Check_Tokens then
627
         if Token_Ptr > Source_First (Current_Source_File)
628
           and then Identifier_Char (Source (Token_Ptr - 1))
629
         then
630
            Error_Space_Required (Token_Ptr);
631
         end if;
632
 
633
         Check_No_Space_After;
634
      end if;
635
   end Check_Left_Paren;
636
 
637
   ---------------------------
638
   -- Check_Line_Max_Length --
639
   ---------------------------
640
 
641
   --  In check max line length mode (-gnatym), the line length must
642
   --  not exceed the permitted maximum value.
643
 
644
   procedure Check_Line_Max_Length (Len : Int) is
645
   begin
646
      if Style_Check_Max_Line_Length then
647
         if Len > Style_Max_Line_Length then
648
            Error_Msg
649
              ("(style) this line is too long",
650
               Current_Line_Start + Source_Ptr (Style_Max_Line_Length));
651
         end if;
652
      end if;
653
   end Check_Line_Max_Length;
654
 
655
   ---------------------------
656
   -- Check_Line_Terminator --
657
   ---------------------------
658
 
659
   --  In check blanks at end mode (-gnatyb), lines may not end with a
660
   --  trailing space.
661
 
662
   --  In check form feeds mode (-gnatyf), the line terminator may not
663
   --  be either of the characters FF or VT.
664
 
665
   --  In check DOS line terminators node (-gnatyd), the line terminator
666
   --  must be a single LF, without a following CR.
667
 
668
   procedure Check_Line_Terminator (Len : Int) is
669
      S : Source_Ptr;
670
 
671
      L : Int := Len;
672
      --  Length of line (adjusted down for blanks at end of line)
673
 
674
   begin
675
      --  Reset count of blank lines if first line
676
 
677
      if Get_Logical_Line_Number (Scan_Ptr) = 1 then
678
         Blank_Lines := 0;
679
      end if;
680
 
681
      --  Check FF/VT terminators
682
 
683
      if Style_Check_Form_Feeds then
684
         if Source (Scan_Ptr) = ASCII.FF then
685
            Error_Msg_S ("(style) form feed not allowed");
686
         elsif Source (Scan_Ptr) = ASCII.VT then
687
            Error_Msg_S ("(style) vertical tab not allowed");
688
         end if;
689
      end if;
690
 
691
      --  Check DOS line terminator
692
 
693
      if Style_Check_DOS_Line_Terminator then
694
 
695
      --  Ignore EOF, since we only get called with an EOF if it is the last
696
      --  character in the buffer (and was therefore not in the source file),
697
      --  since the terminating EOF is added to stop the scan.
698
 
699
         if Source (Scan_Ptr) = EOF then
700
            null;
701
 
702
         --  Bad terminator if we don't have an LF
703
 
704
         elsif Source (Scan_Ptr) /= LF then
705
            Error_Msg_S ("(style) incorrect line terminator");
706
         end if;
707
      end if;
708
 
709
      --  Remove trailing spaces
710
 
711
      S := Scan_Ptr;
712
      while L > 0 and then Is_White_Space (Source (S - 1)) loop
713
         S := S - 1;
714
         L := L - 1;
715
      end loop;
716
 
717
      --  Issue message for blanks at end of line if option enabled
718
 
719
      if Style_Check_Blanks_At_End and then L < Len then
720
         Error_Msg
721
           ("(style) trailing spaces not permitted", S);
722
      end if;
723
 
724
      --  Deal with empty (blank) line
725
 
726
      if L = 0 then
727
 
728
         --  Increment blank line count
729
 
730
         Blank_Lines := Blank_Lines + 1;
731
 
732
         --  If first blank line, record location for later error message
733
 
734
         if Blank_Lines = 1 then
735
            Blank_Line_Location := Scan_Ptr;
736
         end if;
737
 
738
      --  Non-blank line, check for previous multiple blank lines
739
 
740
      else
741
         if Style_Check_Blank_Lines and then Blank_Lines > 1 then
742
            Error_Msg -- CODEFIX
743
              ("(style) multiple blank lines", Blank_Line_Location);
744
         end if;
745
 
746
         --  And reset blank line count
747
 
748
         Blank_Lines := 0;
749
      end if;
750
   end Check_Line_Terminator;
751
 
752
   --------------------------
753
   -- Check_No_Space_After --
754
   --------------------------
755
 
756
   procedure Check_No_Space_After is
757
      S : Source_Ptr;
758
 
759
   begin
760
      if Is_White_Space (Source (Scan_Ptr)) then
761
 
762
         --  Allow one or more spaces if followed by comment
763
 
764
         S := Scan_Ptr + 1;
765
         loop
766
            if Source (S) = '-' and then Source (S + 1) = '-' then
767
               return;
768
 
769
            elsif Is_White_Space (Source (S)) then
770
               S := S + 1;
771
 
772
            else
773
               exit;
774
            end if;
775
         end loop;
776
 
777
         Error_Space_Not_Allowed (Scan_Ptr);
778
      end if;
779
   end Check_No_Space_After;
780
 
781
   ---------------------------
782
   -- Check_No_Space_Before --
783
   ---------------------------
784
 
785
   procedure Check_No_Space_Before is
786
   begin
787
      if Token_Ptr > First_Non_Blank_Location
788
         and then Source (Token_Ptr - 1) <= ' '
789
      then
790
         Error_Space_Not_Allowed (Token_Ptr - 1);
791
      end if;
792
   end Check_No_Space_Before;
793
 
794
   -----------------------
795
   -- Check_Pragma_Name --
796
   -----------------------
797
 
798
   --  In check pragma casing mode (-gnatyp), pragma names must be mixed
799
   --  case, i.e. start with an upper case letter, and otherwise lower case,
800
   --  except after an underline character.
801
 
802
   procedure Check_Pragma_Name is
803
   begin
804
      if Style_Check_Pragma_Casing then
805
         if Determine_Token_Casing /= Mixed_Case then
806
            Error_Msg_SC -- CODEFIX
807
              ("(style) bad capitalization, mixed case required");
808
         end if;
809
      end if;
810
   end Check_Pragma_Name;
811
 
812
   -----------------------
813
   -- Check_Right_Paren --
814
   -----------------------
815
 
816
   --  In check tokens mode (-gnatyt), right paren must not be immediately
817
   --  followed by an identifier character, and must never be preceded by
818
   --  a space unless it is the initial non-blank character on the line.
819
 
820
   procedure Check_Right_Paren is
821
   begin
822
      if Style_Check_Tokens then
823
         if Identifier_Char (Source (Token_Ptr + 1)) then
824
            Error_Space_Required (Token_Ptr + 1);
825
         end if;
826
 
827
         Check_No_Space_Before;
828
      end if;
829
   end Check_Right_Paren;
830
 
831
   ---------------------
832
   -- Check_Semicolon --
833
   ---------------------
834
 
835
   --  In check tokens mode (-gnatyt), semicolon does not permit a preceding
836
   --  space and a following space is required.
837
 
838
   procedure Check_Semicolon is
839
   begin
840
      if Style_Check_Tokens then
841
         Check_No_Space_Before;
842
 
843
         if Source (Scan_Ptr) > ' ' then
844
            Error_Space_Required (Scan_Ptr);
845
         end if;
846
      end if;
847
   end Check_Semicolon;
848
 
849
   -------------------------------
850
   -- Check_Separate_Stmt_Lines --
851
   -------------------------------
852
 
853
   procedure Check_Separate_Stmt_Lines is
854
   begin
855
      if Style_Check_Separate_Stmt_Lines then
856
         Check_Separate_Stmt_Lines_Cont;
857
      end if;
858
   end Check_Separate_Stmt_Lines;
859
 
860
   ------------------------------------
861
   -- Check_Separate_Stmt_Lines_Cont --
862
   ------------------------------------
863
 
864
   procedure Check_Separate_Stmt_Lines_Cont is
865
      S : Source_Ptr;
866
 
867
   begin
868
      --  Skip past white space
869
 
870
      S := Scan_Ptr;
871
      while Is_White_Space (Source (S)) loop
872
         S := S + 1;
873
      end loop;
874
 
875
      --  Line terminator is OK
876
 
877
      if Source (S) in Line_Terminator then
878
         return;
879
 
880
      --  Comment is OK
881
 
882
      elsif Source (S) = '-' and then Source (S + 1) = '-' then
883
         return;
884
 
885
      --  ABORT keyword is OK after THEN (THEN ABORT case)
886
 
887
      elsif Token = Tok_Then
888
        and then (Source (S + 0) = 'a' or else Source (S + 0) = 'A')
889
        and then (Source (S + 1) = 'b' or else Source (S + 1) = 'B')
890
        and then (Source (S + 2) = 'o' or else Source (S + 2) = 'O')
891
        and then (Source (S + 3) = 'r' or else Source (S + 3) = 'R')
892
        and then (Source (S + 4) = 't' or else Source (S + 4) = 'T')
893
        and then (Source (S + 5) in Line_Terminator
894
                   or else Is_White_Space (Source (S + 5)))
895
      then
896
         return;
897
 
898
      --  PRAGMA keyword is OK after ELSE
899
 
900
      elsif Token = Tok_Else
901
        and then (Source (S + 0) = 'p' or else Source (S + 0) = 'P')
902
        and then (Source (S + 1) = 'r' or else Source (S + 1) = 'R')
903
        and then (Source (S + 2) = 'a' or else Source (S + 2) = 'A')
904
        and then (Source (S + 3) = 'g' or else Source (S + 3) = 'G')
905
        and then (Source (S + 4) = 'm' or else Source (S + 4) = 'M')
906
        and then (Source (S + 5) = 'a' or else Source (S + 5) = 'A')
907
        and then (Source (S + 6) in Line_Terminator
908
                   or else Is_White_Space (Source (S + 6)))
909
      then
910
         return;
911
 
912
         --  Otherwise we have the style violation we are looking for
913
 
914
      else
915
         if Token = Tok_Then then
916
            Error_Msg
917
              ("(style) no statements may follow THEN on same line", S);
918
         else
919
            Error_Msg
920
              ("(style) no statements may follow ELSE on same line", S);
921
         end if;
922
      end if;
923
   end Check_Separate_Stmt_Lines_Cont;
924
 
925
   ----------------
926
   -- Check_Then --
927
   ----------------
928
 
929
   --  In check if then layout mode (-gnatyi), we expect a THEN keyword
930
   --  to appear either on the same line as the IF, or on a separate line
931
   --  after multiple conditions. In any case, it may not appear on the
932
   --  line immediately following the line with the IF.
933
 
934
   procedure Check_Then (If_Loc : Source_Ptr) is
935
   begin
936
      if Style_Check_If_Then_Layout then
937
         if Get_Physical_Line_Number (Token_Ptr) =
938
            Get_Physical_Line_Number (If_Loc) + 1
939
         then
940
            Error_Msg_SC ("(style) misplaced THEN");
941
         end if;
942
      end if;
943
   end Check_Then;
944
 
945
   -------------------------------
946
   -- Check_Unary_Plus_Or_Minus --
947
   -------------------------------
948
 
949
   --  In check token mode (-gnatyt), unary plus or minus must not be
950
   --  followed by a space.
951
 
952
   procedure Check_Unary_Plus_Or_Minus is
953
   begin
954
      if Style_Check_Tokens then
955
         Check_No_Space_After;
956
      end if;
957
   end Check_Unary_Plus_Or_Minus;
958
 
959
   ------------------------
960
   -- Check_Vertical_Bar --
961
   ------------------------
962
 
963
   --  In check token mode (-gnatyt), vertical bar must be surrounded by spaces
964
 
965
   procedure Check_Vertical_Bar is
966
   begin
967
      if Style_Check_Tokens then
968
         Require_Preceding_Space;
969
         Require_Following_Space;
970
      end if;
971
   end Check_Vertical_Bar;
972
 
973
   -----------------------
974
   -- Check_Xtra_Parens --
975
   -----------------------
976
 
977
   procedure Check_Xtra_Parens (Loc : Source_Ptr) is
978
   begin
979
      if Style_Check_Xtra_Parens then
980
         Error_Msg ("redundant parentheses?", Loc);
981
      end if;
982
   end Check_Xtra_Parens;
983
 
984
   ----------------------------
985
   -- Determine_Token_Casing --
986
   ----------------------------
987
 
988
   function Determine_Token_Casing return Casing_Type is
989
   begin
990
      return Determine_Casing (Source (Token_Ptr .. Scan_Ptr - 1));
991
   end Determine_Token_Casing;
992
 
993
   -----------------------------
994
   -- Error_Space_Not_Allowed --
995
   -----------------------------
996
 
997
   procedure Error_Space_Not_Allowed (S : Source_Ptr) is
998
   begin
999
      Error_Msg ("(style) space not allowed", S);
1000
   end Error_Space_Not_Allowed;
1001
 
1002
   --------------------------
1003
   -- Error_Space_Required --
1004
   --------------------------
1005
 
1006
   procedure Error_Space_Required (S : Source_Ptr) is
1007
   begin
1008
      Error_Msg ("(style) space required", S);
1009
   end Error_Space_Required;
1010
 
1011
   --------------------
1012
   -- Is_White_Space --
1013
   --------------------
1014
 
1015
   function Is_White_Space (C : Character) return Boolean is
1016
   begin
1017
      return C = ' ' or else C = HT;
1018
   end Is_White_Space;
1019
 
1020
   -------------------
1021
   -- Mode_In_Check --
1022
   -------------------
1023
 
1024
   function Mode_In_Check return Boolean is
1025
   begin
1026
      return Style_Check and Style_Check_Mode_In;
1027
   end Mode_In_Check;
1028
 
1029
   -----------------
1030
   -- No_End_Name --
1031
   -----------------
1032
 
1033
   --  In check end/exit labels mode (-gnatye), always require the name of
1034
   --  a subprogram or package to be present on the END, so this is an error.
1035
 
1036
   procedure No_End_Name (Name : Node_Id) is
1037
   begin
1038
      if Style_Check_End_Labels then
1039
         Error_Msg_Node_1 := Name;
1040
         Error_Msg_SP ("(style) `END &` required");
1041
      end if;
1042
   end No_End_Name;
1043
 
1044
   ------------------
1045
   -- No_Exit_Name --
1046
   ------------------
1047
 
1048
   --  In check end/exit labels mode (-gnatye), always require the name of
1049
   --  the loop to be present on the EXIT when exiting a named loop.
1050
 
1051
   procedure No_Exit_Name (Name : Node_Id) is
1052
   begin
1053
      if Style_Check_End_Labels then
1054
         Error_Msg_Node_1 := Name;
1055
         Error_Msg_SP ("(style) `EXIT &` required");
1056
      end if;
1057
   end No_Exit_Name;
1058
 
1059
   ----------------------------
1060
   -- Non_Lower_Case_Keyword --
1061
   ----------------------------
1062
 
1063
   --  In check casing mode (-gnatyk), reserved keywords must be spelled
1064
   --  in all lower case (excluding keywords range, access, delta and digits
1065
   --  used as attribute designators).
1066
 
1067
   procedure Non_Lower_Case_Keyword is
1068
   begin
1069
      if Style_Check_Keyword_Casing then
1070
         Error_Msg_SC -- CODEIX
1071
           ("(style) reserved words must be all lower case");
1072
      end if;
1073
   end Non_Lower_Case_Keyword;
1074
 
1075
   -----------------------------
1076
   -- Require_Following_Space --
1077
   -----------------------------
1078
 
1079
   procedure Require_Following_Space is
1080
   begin
1081
      if Source (Scan_Ptr) > ' ' then
1082
         Error_Space_Required (Scan_Ptr);
1083
      end if;
1084
   end Require_Following_Space;
1085
 
1086
   -----------------------------
1087
   -- Require_Preceding_Space --
1088
   -----------------------------
1089
 
1090
   procedure Require_Preceding_Space is
1091
   begin
1092
      if Token_Ptr > Source_First (Current_Source_File)
1093
        and then Source (Token_Ptr - 1) > ' '
1094
      then
1095
         Error_Space_Required (Token_Ptr);
1096
      end if;
1097
   end Require_Preceding_Space;
1098
 
1099
end Styleg;

powered by: WebSVN 2.1.0

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