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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [ada/] [par-util.adb] - Blame information for rev 316

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 281 jeremybenn
------------------------------------------------------------------------------
2
--                                                                          --
3
--                         GNAT COMPILER COMPONENTS                         --
4
--                                                                          --
5
--                             P A R . U T I L                              --
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
with Csets;    use Csets;
27
with Namet.Sp; use Namet.Sp;
28
with Stylesw;  use Stylesw;
29
with Uintp;    use Uintp;
30
 
31
with GNAT.Spelling_Checker; use GNAT.Spelling_Checker;
32
 
33
separate (Par)
34
package body Util is
35
 
36
   ---------------------
37
   -- Bad_Spelling_Of --
38
   ---------------------
39
 
40
   function Bad_Spelling_Of (T : Token_Type) return Boolean is
41
      Tname : constant String := Token_Type'Image (T);
42
      --  Characters of token name
43
 
44
      S : String (1 .. Tname'Last - 4);
45
      --  Characters of token name folded to lower case, omitting TOK_ at start
46
 
47
      M1 : String (1 .. 42) := "incorrect spelling of keyword ************";
48
      M2 : String (1 .. 44) := "illegal abbreviation of keyword ************";
49
      --  Buffers used to construct error message
50
 
51
      P1 : constant := 30;
52
      P2 : constant := 32;
53
      --  Starting subscripts in M1, M2 for keyword name
54
 
55
      SL : constant Natural := S'Length;
56
      --  Length of expected token name excluding TOK_ at start
57
 
58
   begin
59
      if Token /= Tok_Identifier then
60
         return False;
61
      end if;
62
 
63
      for J in S'Range loop
64
         S (J) := Fold_Lower (Tname (J + 4));
65
      end loop;
66
 
67
      Get_Name_String (Token_Name);
68
 
69
      --  A special check for case of PROGRAM used for PROCEDURE
70
 
71
      if T = Tok_Procedure
72
        and then Name_Len = 7
73
        and then Name_Buffer (1 .. 7) = "program"
74
      then
75
         Error_Msg_SC ("PROCEDURE expected");
76
         Token := T;
77
         return True;
78
 
79
      --  A special check for an illegal abbreviation
80
 
81
      elsif Name_Len < S'Length
82
        and then Name_Len >= 4
83
        and then Name_Buffer (1 .. Name_Len) = S (1 .. Name_Len)
84
      then
85
         for J in 1 .. S'Last loop
86
            M2 (P2 + J - 1) := Fold_Upper (S (J));
87
         end loop;
88
 
89
         Error_Msg_SC -- CODEFIX???
90
           (M2 (1 .. P2 - 1 + S'Last));
91
         Token := T;
92
         return True;
93
      end if;
94
 
95
      --  Now we go into the full circuit to check for a misspelling
96
 
97
      --  Never consider something a misspelling if either the actual or
98
      --  expected string is less than 3 characters (before this check we
99
      --  used to consider i to be a misspelled if in some cases!)
100
 
101
      if SL < 3 or else Name_Len < 3 then
102
         return False;
103
 
104
      --  Special case: prefix matches, i.e. the leading characters of the
105
      --  token that we have exactly match the required keyword. If there
106
      --  are at least two characters left over, assume that we have a case
107
      --  of two keywords joined together which should not be joined.
108
 
109
      elsif Name_Len > SL + 1
110
        and then S = Name_Buffer (1 .. SL)
111
      then
112
         Scan_Ptr := Token_Ptr + S'Length;
113
         Error_Msg_S ("|missing space");
114
         Token := T;
115
         return True;
116
      end if;
117
 
118
      if Is_Bad_Spelling_Of (Name_Buffer (1 .. Name_Len), S) then
119
         for J in 1 .. S'Last loop
120
            M1 (P1 + J - 1) := Fold_Upper (S (J));
121
         end loop;
122
 
123
         Error_Msg_SC -- CODFIX
124
           (M1 (1 .. P1 - 1 + S'Last));
125
         Token := T;
126
         return True;
127
 
128
      else
129
         return False;
130
      end if;
131
   end Bad_Spelling_Of;
132
 
133
   ----------------------
134
   -- Check_95_Keyword --
135
   ----------------------
136
 
137
   --  On entry, the caller has checked that current token is an identifier
138
   --  whose name matches the name of the 95 keyword New_Tok.
139
 
140
   procedure Check_95_Keyword (Token_95, Next : Token_Type) is
141
      Scan_State : Saved_Scan_State;
142
 
143
   begin
144
      Save_Scan_State (Scan_State); -- at identifier/keyword
145
      Scan; -- past identifier/keyword
146
 
147
      if Token = Next then
148
         Restore_Scan_State (Scan_State); -- to identifier
149
         Error_Msg_Name_1 := Token_Name;
150
         Error_Msg_SC ("(Ada 83) keyword* cannot be used!");
151
         Token := Token_95;
152
      else
153
         Restore_Scan_State (Scan_State); -- to identifier
154
      end if;
155
   end Check_95_Keyword;
156
 
157
   ----------------------
158
   -- Check_Bad_Layout --
159
   ----------------------
160
 
161
   procedure Check_Bad_Layout is
162
   begin
163
      if RM_Column_Check and then Token_Is_At_Start_Of_Line
164
        and then Start_Column <= Scope.Table (Scope.Last).Ecol
165
      then
166
         Error_Msg_BC -- CODEFIX
167
           ("(style) incorrect layout");
168
      end if;
169
   end Check_Bad_Layout;
170
 
171
   --------------------------
172
   -- Check_Misspelling_Of --
173
   --------------------------
174
 
175
   procedure Check_Misspelling_Of (T : Token_Type) is
176
   begin
177
      if Bad_Spelling_Of (T) then
178
         null;
179
      end if;
180
   end Check_Misspelling_Of;
181
 
182
   -----------------------------
183
   -- Check_Simple_Expression --
184
   -----------------------------
185
 
186
   procedure Check_Simple_Expression (E : Node_Id) is
187
   begin
188
      if Expr_Form = EF_Non_Simple then
189
         Error_Msg_N ("this expression must be parenthesized", E);
190
      end if;
191
   end Check_Simple_Expression;
192
 
193
   ---------------------------------------
194
   -- Check_Simple_Expression_In_Ada_83 --
195
   ---------------------------------------
196
 
197
   procedure Check_Simple_Expression_In_Ada_83 (E : Node_Id) is
198
   begin
199
      if Expr_Form = EF_Non_Simple then
200
         if Ada_Version = Ada_83 then
201
            Error_Msg_N ("(Ada 83) this expression must be parenthesized!", E);
202
         end if;
203
      end if;
204
   end Check_Simple_Expression_In_Ada_83;
205
 
206
   ------------------------
207
   -- Check_Subtype_Mark --
208
   ------------------------
209
 
210
   function Check_Subtype_Mark (Mark : Node_Id) return Node_Id is
211
   begin
212
      if Nkind (Mark) = N_Identifier
213
        or else Nkind (Mark) = N_Selected_Component
214
        or else (Nkind (Mark) = N_Attribute_Reference
215
                  and then Is_Type_Attribute_Name (Attribute_Name (Mark)))
216
        or else Mark = Error
217
      then
218
         return Mark;
219
      else
220
         Error_Msg ("subtype mark expected", Sloc (Mark));
221
         return Error;
222
      end if;
223
   end Check_Subtype_Mark;
224
 
225
   -------------------
226
   -- Comma_Present --
227
   -------------------
228
 
229
   function Comma_Present return Boolean is
230
      Scan_State  : Saved_Scan_State;
231
      Paren_Count : Nat;
232
 
233
   begin
234
      --  First check, if a comma is present, then a comma is present!
235
 
236
      if Token = Tok_Comma then
237
         T_Comma;
238
         return True;
239
 
240
      --  If we have a right paren, then that is taken as ending the list
241
      --  i.e. no comma is present.
242
 
243
      elsif Token = Tok_Right_Paren then
244
         return False;
245
 
246
      --  If pragmas, then get rid of them and make a recursive call
247
      --  to process what follows these pragmas.
248
 
249
      elsif Token = Tok_Pragma then
250
         P_Pragmas_Misplaced;
251
         return Comma_Present;
252
 
253
      --  At this stage we have an error, and the goal is to decide on whether
254
      --  or not we should diagnose an error and report a (non-existent)
255
      --  comma as being present, or simply to report no comma is present
256
 
257
      --  If we are a semicolon, then the question is whether we have a missing
258
      --  right paren, or whether the semicolon should have been a comma. To
259
      --  guess the right answer, we scan ahead keeping track of the paren
260
      --  level, looking for a clue that helps us make the right decision.
261
 
262
      --  This approach is highly accurate in the single error case, and does
263
      --  not make bad mistakes in the multiple error case (indeed we can't
264
      --  really make a very bad decision at this point in any case).
265
 
266
      elsif Token = Tok_Semicolon then
267
         Save_Scan_State (Scan_State);
268
         Scan; -- past semicolon
269
 
270
         --  Check for being followed by identifier => which almost certainly
271
         --  means we are still in a parameter list and the comma should have
272
         --  been a semicolon (such a sequence could not follow a semicolon)
273
 
274
         if Token = Tok_Identifier then
275
            Scan;
276
 
277
            if Token = Tok_Arrow then
278
               goto Assume_Comma;
279
            end if;
280
         end if;
281
 
282
         --  If that test didn't work, loop ahead looking for a comma or
283
         --  semicolon at the same parenthesis level. Always remember that
284
         --  we can't go badly wrong in an error situation like this!
285
 
286
         Paren_Count := 0;
287
 
288
         --  Here is the look ahead loop, Paren_Count tells us whether the
289
         --  token we are looking at is at the same paren level as the
290
         --  suspicious semicolon that we are trying to figure out.
291
 
292
         loop
293
 
294
            --  If we hit another semicolon or an end of file, and we have
295
            --  not seen a right paren or another comma on the way, then
296
            --  probably the semicolon did end the list. Indeed that is
297
            --  certainly the only single error correction possible here.
298
 
299
            if Token = Tok_Semicolon or else Token = Tok_EOF then
300
               Restore_Scan_State (Scan_State);
301
               return False;
302
 
303
            --  A comma at the same paren level as the semicolon is a strong
304
            --  indicator that the semicolon should have been a comma, indeed
305
            --  again this is the only possible single error correction.
306
 
307
            elsif Token = Tok_Comma then
308
               exit when Paren_Count = 0;
309
 
310
            --  A left paren just bumps the paren count
311
 
312
            elsif Token = Tok_Left_Paren then
313
               Paren_Count := Paren_Count + 1;
314
 
315
            --  A right paren that is at the same paren level as the semicolon
316
            --  also means that the only possible single error correction is
317
            --  to assume that the semicolon should have been a comma. If we
318
            --  are not at the same paren level, then adjust the paren level.
319
 
320
            elsif Token = Tok_Right_Paren then
321
               exit when Paren_Count = 0;
322
               Paren_Count := Paren_Count - 1;
323
            end if;
324
 
325
            --  Keep going, we haven't made a decision yet
326
 
327
            Scan;
328
         end loop;
329
 
330
         --  If we fall through the loop, it means that we found a terminating
331
         --  right paren or another comma. In either case it is reasonable to
332
         --  assume that the semicolon was really intended to be a comma. Also
333
         --  come here for the identifier arrow case.
334
 
335
         <<Assume_Comma>>
336
            Restore_Scan_State (Scan_State);
337
            Error_Msg_SC ("|"";"" should be "",""");
338
            Scan; -- past the semicolon
339
            return True;
340
 
341
      --  If we are not at semicolon or a right paren, then we base the
342
      --  decision on whether or not the next token can be part of an
343
      --  expression. If not, then decide that no comma is present (the
344
      --  caller will eventually generate a missing right parent message)
345
 
346
      elsif Token in Token_Class_Eterm then
347
         return False;
348
 
349
      --  Otherwise we assume a comma is present, even if none is present,
350
      --  since the next token must be part of an expression, so if we were
351
      --  at the end of the list, then there is more than one error present.
352
 
353
      else
354
         T_Comma; -- to give error
355
         return True;
356
      end if;
357
   end Comma_Present;
358
 
359
   -----------------------
360
   -- Discard_Junk_List --
361
   -----------------------
362
 
363
   procedure Discard_Junk_List (L : List_Id) is
364
      pragma Warnings (Off, L);
365
   begin
366
      null;
367
   end Discard_Junk_List;
368
 
369
   -----------------------
370
   -- Discard_Junk_Node --
371
   -----------------------
372
 
373
   procedure Discard_Junk_Node (N : Node_Id) is
374
      pragma Warnings (Off, N);
375
   begin
376
      null;
377
   end Discard_Junk_Node;
378
 
379
   ------------
380
   -- Ignore --
381
   ------------
382
 
383
   procedure Ignore (T : Token_Type) is
384
   begin
385
      while Token = T loop
386
         if T = Tok_Comma then
387
            Error_Msg_SC ("|extra "","" ignored");
388
 
389
         elsif T = Tok_Left_Paren then
390
            Error_Msg_SC ("|extra ""("" ignored");
391
 
392
         elsif T = Tok_Right_Paren then
393
            Error_Msg_SC ("|extra "")"" ignored");
394
 
395
         elsif T = Tok_Semicolon then
396
            Error_Msg_SC ("|extra "";"" ignored");
397
 
398
         elsif T = Tok_Colon then
399
            Error_Msg_SC ("|extra "":"" ignored");
400
 
401
         else
402
            declare
403
               Tname : constant String := Token_Type'Image (Token);
404
            begin
405
               Error_Msg_SC
406
                 ("|extra " & Tname (5 .. Tname'Last) & "ignored");
407
            end;
408
         end if;
409
 
410
         Scan; -- Scan past ignored token
411
      end loop;
412
   end Ignore;
413
 
414
   ----------------------------
415
   -- Is_Reserved_Identifier --
416
   ----------------------------
417
 
418
   function Is_Reserved_Identifier (C : Id_Check := None) return Boolean is
419
   begin
420
      if not Is_Reserved_Keyword (Token) then
421
         return False;
422
 
423
      else
424
         declare
425
            Ident_Casing : constant Casing_Type :=
426
                             Identifier_Casing (Current_Source_File);
427
            Key_Casing   : constant Casing_Type :=
428
                             Keyword_Casing (Current_Source_File);
429
 
430
         begin
431
            --  If the casing of identifiers and keywords is different in
432
            --  this source file, and the casing of this token matches the
433
            --  keyword casing, then we return False, since it is pretty
434
            --  clearly intended to be a keyword.
435
 
436
            if Ident_Casing = Unknown
437
              or else Key_Casing = Unknown
438
              or else Ident_Casing = Key_Casing
439
              or else Determine_Token_Casing /= Key_Casing
440
            then
441
               return True;
442
 
443
            --  Here we have a keyword written clearly with keyword casing.
444
            --  In default mode, we would not be willing to consider this as
445
            --  a reserved identifier, but if C is set, we may still accept it
446
 
447
            elsif C /= None then
448
               declare
449
                  Scan_State  : Saved_Scan_State;
450
                  OK_Next_Tok : Boolean;
451
 
452
               begin
453
                  Save_Scan_State (Scan_State);
454
                  Scan;
455
 
456
                  if Token_Is_At_Start_Of_Line then
457
                     return False;
458
                  end if;
459
 
460
                  case C is
461
                     when None =>
462
                        raise Program_Error;
463
 
464
                     when C_Comma_Right_Paren =>
465
                        OK_Next_Tok :=
466
                          Token = Tok_Comma or else Token = Tok_Right_Paren;
467
 
468
                     when C_Comma_Colon =>
469
                        OK_Next_Tok :=
470
                          Token = Tok_Comma or else Token = Tok_Colon;
471
 
472
                     when C_Do =>
473
                        OK_Next_Tok :=
474
                          Token = Tok_Do;
475
 
476
                     when C_Dot =>
477
                        OK_Next_Tok :=
478
                          Token = Tok_Dot;
479
 
480
                     when C_Greater_Greater =>
481
                        OK_Next_Tok :=
482
                          Token = Tok_Greater_Greater;
483
 
484
                     when C_In =>
485
                        OK_Next_Tok :=
486
                          Token = Tok_In;
487
 
488
                     when C_Is =>
489
                        OK_Next_Tok :=
490
                          Token = Tok_Is;
491
 
492
                     when C_Left_Paren_Semicolon =>
493
                        OK_Next_Tok :=
494
                          Token = Tok_Left_Paren or else Token = Tok_Semicolon;
495
 
496
                     when C_Use =>
497
                        OK_Next_Tok :=
498
                          Token = Tok_Use;
499
 
500
                     when C_Vertical_Bar_Arrow =>
501
                        OK_Next_Tok :=
502
                          Token = Tok_Vertical_Bar or else Token = Tok_Arrow;
503
                  end case;
504
 
505
                  Restore_Scan_State (Scan_State);
506
 
507
                  if OK_Next_Tok then
508
                     return True;
509
                  end if;
510
               end;
511
            end if;
512
         end;
513
      end if;
514
 
515
      --  If we fall through it is not a reserved identifier
516
 
517
      return False;
518
   end Is_Reserved_Identifier;
519
 
520
   ----------------------
521
   -- Merge_Identifier --
522
   ----------------------
523
 
524
   procedure Merge_Identifier (Prev : Node_Id; Nxt : Token_Type) is
525
   begin
526
      if Token /= Tok_Identifier then
527
         return;
528
      end if;
529
 
530
      declare
531
         S : Saved_Scan_State;
532
         T : Token_Type;
533
 
534
      begin
535
         Save_Scan_State (S);
536
         Scan;
537
         T := Token;
538
         Restore_Scan_State (S);
539
 
540
         if T /= Nxt then
541
            return;
542
         end if;
543
      end;
544
 
545
      --  Check exactly one space between identifiers
546
 
547
      if Source (Token_Ptr - 1) /= ' '
548
        or else Int (Token_Ptr) /=
549
                  Int (Prev_Token_Ptr) + Length_Of_Name (Chars (Prev)) + 1
550
      then
551
         return;
552
      end if;
553
 
554
      --  Do the merge
555
 
556
      Get_Name_String (Chars (Token_Node));
557
 
558
      declare
559
         Buf : constant String (1 .. Name_Len) :=
560
                 Name_Buffer (1 .. Name_Len);
561
 
562
      begin
563
         Get_Name_String (Chars (Prev));
564
         Add_Char_To_Name_Buffer ('_');
565
         Add_Str_To_Name_Buffer (Buf);
566
         Set_Chars (Prev, Name_Find);
567
      end;
568
 
569
      Error_Msg_Node_1 := Prev;
570
      Error_Msg_SC
571
        ("unexpected identifier, possibly & was meant here");
572
      Scan;
573
   end Merge_Identifier;
574
 
575
   -------------------
576
   -- Next_Token_Is --
577
   -------------------
578
 
579
   function Next_Token_Is (Tok : Token_Type) return Boolean is
580
      Scan_State : Saved_Scan_State;
581
      Result     : Boolean;
582
   begin
583
      Save_Scan_State (Scan_State);
584
      Scan;
585
      Result := (Token = Tok);
586
      Restore_Scan_State (Scan_State);
587
      return Result;
588
   end Next_Token_Is;
589
 
590
   -------------------
591
   -- No_Constraint --
592
   -------------------
593
 
594
   procedure No_Constraint is
595
   begin
596
      if Token in Token_Class_Consk then
597
         Error_Msg_SC ("constraint not allowed here");
598
         Discard_Junk_Node (P_Constraint_Opt);
599
      end if;
600
   end No_Constraint;
601
 
602
   ---------------------
603
   -- Pop_Scope_Stack --
604
   ---------------------
605
 
606
   procedure Pop_Scope_Stack is
607
   begin
608
      pragma Assert (Scope.Last > 0);
609
      Scope.Decrement_Last;
610
 
611
      if Debug_Flag_P then
612
         Error_Msg_Uint_1 := UI_From_Int (Scope.Last);
613
         Error_Msg_SC ("decrement scope stack ptr, new value = ^!");
614
      end if;
615
   end Pop_Scope_Stack;
616
 
617
   ----------------------
618
   -- Push_Scope_Stack --
619
   ----------------------
620
 
621
   procedure Push_Scope_Stack is
622
   begin
623
      Scope.Increment_Last;
624
 
625
      if Style_Check_Max_Nesting_Level
626
        and then Scope.Last = Style_Max_Nesting_Level + 1
627
      then
628
         Error_Msg
629
           ("(style) maximum nesting level exceeded",
630
            First_Non_Blank_Location);
631
      end if;
632
 
633
      Scope.Table (Scope.Last).Junk := False;
634
      Scope.Table (Scope.Last).Node := Empty;
635
 
636
      if Debug_Flag_P then
637
         Error_Msg_Uint_1 := UI_From_Int (Scope.Last);
638
         Error_Msg_SC ("increment scope stack ptr, new value = ^!");
639
      end if;
640
   end Push_Scope_Stack;
641
 
642
   ----------------------
643
   -- Separate_Present --
644
   ----------------------
645
 
646
   function Separate_Present return Boolean is
647
      Scan_State : Saved_Scan_State;
648
 
649
   begin
650
      if Token = Tok_Separate then
651
         return True;
652
 
653
      elsif Token /= Tok_Identifier then
654
         return False;
655
 
656
      else
657
         Save_Scan_State (Scan_State);
658
         Scan; -- past identifier
659
 
660
         if Token = Tok_Semicolon then
661
            Restore_Scan_State (Scan_State);
662
            return Bad_Spelling_Of (Tok_Separate);
663
 
664
         else
665
            Restore_Scan_State (Scan_State);
666
            return False;
667
         end if;
668
      end if;
669
   end Separate_Present;
670
 
671
   --------------------------
672
   -- Signal_Bad_Attribute --
673
   --------------------------
674
 
675
   procedure Signal_Bad_Attribute is
676
   begin
677
      Error_Msg_N ("unrecognized attribute&", Token_Node);
678
 
679
      --  Check for possible misspelling
680
 
681
      Error_Msg_Name_1 := First_Attribute_Name;
682
      while Error_Msg_Name_1 <= Last_Attribute_Name loop
683
         if Is_Bad_Spelling_Of (Token_Name, Error_Msg_Name_1) then
684
            Error_Msg_N -- CODEFIX
685
              ("\possible misspelling of %", Token_Node);
686
            exit;
687
         end if;
688
 
689
         Error_Msg_Name_1 := Error_Msg_Name_1 + 1;
690
      end loop;
691
   end Signal_Bad_Attribute;
692
 
693
   -----------------------------
694
   -- Token_Is_At_End_Of_Line --
695
   -----------------------------
696
 
697
   function Token_Is_At_End_Of_Line return Boolean is
698
      S : Source_Ptr;
699
 
700
   begin
701
      --  Skip past blanks and horizontal tabs
702
 
703
      S := Scan_Ptr;
704
      while Source (S) = ' ' or else Source (S) = ASCII.HT loop
705
         S := S + 1;
706
      end loop;
707
 
708
      --  We are at end of line if at a control character (CR/LF/VT/FF/EOF)
709
      --  or if we are at the start of an end of line comment sequence.
710
 
711
      return Source (S) < ' '
712
        or else (Source (S) = '-' and then Source (S + 1) = '-');
713
   end Token_Is_At_End_Of_Line;
714
 
715
   -------------------------------
716
   -- Token_Is_At_Start_Of_Line --
717
   -------------------------------
718
 
719
   function Token_Is_At_Start_Of_Line return Boolean is
720
   begin
721
      return (Token_Ptr = First_Non_Blank_Location or else Token = Tok_EOF);
722
   end Token_Is_At_Start_Of_Line;
723
 
724
end Util;

powered by: WebSVN 2.1.0

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