File : xref_lib.adb
1 ------------------------------------------------------------------------------
2 -- --
3 -- GNAT COMPILER COMPONENTS --
4 -- --
5 -- X R E F _ L I B --
6 -- --
7 -- B o d y --
8 -- --
9 -- Copyright (C) 1998-2016, 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 Osint;
27 with Output; use Output;
28 with Types; use Types;
29
30 with Unchecked_Deallocation;
31
32 with Ada.Strings.Fixed; use Ada.Strings.Fixed;
33 with Ada.Text_IO; use Ada.Text_IO;
34
35 with GNAT.Command_Line; use GNAT.Command_Line;
36 with GNAT.IO_Aux; use GNAT.IO_Aux;
37
38 package body Xref_Lib is
39
40 Type_Position : constant := 50;
41 -- Column for label identifying type of entity
42
43 ---------------------
44 -- Local Variables --
45 ---------------------
46
47 Pipe : constant Character := '|';
48 -- First character on xref lines in the .ali file
49
50 No_Xref_Information : exception;
51 -- Exception raised when there is no cross-referencing information in
52 -- the .ali files.
53
54 procedure Parse_EOL
55 (Source : not null access String;
56 Ptr : in out Positive;
57 Skip_Continuation_Line : Boolean := False);
58 -- On return Source (Ptr) is the first character of the next line
59 -- or EOF. Source.all must be terminated by EOF.
60 --
61 -- If Skip_Continuation_Line is True, this subprogram skips as many
62 -- lines as required when the second or more lines starts with '.'
63 -- (continuation lines in ALI files).
64
65 function Current_Xref_File (File : ALI_File) return File_Reference;
66 -- Return the file matching the last 'X' line we found while parsing
67 -- the ALI file.
68
69 function File_Name (File : ALI_File; Num : Positive) return File_Reference;
70 -- Returns the dependency file name number Num
71
72 function Get_Full_Type (Decl : Declaration_Reference) return String;
73 -- Returns the full type corresponding to a type letter as found in
74 -- the .ali files.
75
76 procedure Open
77 (Name : String;
78 File : out ALI_File;
79 Dependencies : Boolean := False);
80 -- Open a new ALI file. If Dependencies is True, the insert every library
81 -- file 'with'ed in the files database (used for gnatxref)
82
83 procedure Parse_Identifier_Info
84 (Pattern : Search_Pattern;
85 File : in out ALI_File;
86 Local_Symbols : Boolean;
87 Der_Info : Boolean := False;
88 Type_Tree : Boolean := False;
89 Wide_Search : Boolean := True;
90 Labels_As_Ref : Boolean := True);
91 -- Output the file and the line where the identifier was referenced,
92 -- If Local_Symbols is False then only the publicly visible symbols
93 -- will be processed.
94 --
95 -- If Labels_As_Ref is true, then the references to the entities after
96 -- the end statements ("end Foo") will be counted as actual references.
97 -- The entity will never be reported as unreferenced by gnatxref -u
98
99 procedure Parse_Token
100 (Source : not null access String;
101 Ptr : in out Positive;
102 Token_Ptr : out Positive);
103 -- Skips any separators and stores the start of the token in Token_Ptr.
104 -- Then stores the position of the next separator in Ptr. On return
105 -- Source (Token_Ptr .. Ptr - 1) is the token. Separators are space
106 -- and ASCII.HT. Parse_Token will never skip to the next line.
107
108 procedure Parse_Number
109 (Source : not null access String;
110 Ptr : in out Positive;
111 Number : out Natural);
112 -- Skips any separators and parses Source up to the first character that
113 -- is not a decimal digit. Returns value of parsed digits or 0 if none.
114
115 procedure Parse_X_Filename (File : in out ALI_File);
116 -- Reads and processes "X..." lines in the ALI file
117 -- and updates the File.X_File information.
118
119 procedure Skip_To_First_X_Line
120 (File : in out ALI_File;
121 D_Lines : Boolean;
122 W_Lines : Boolean);
123 -- Skip the lines in the ALI file until the first cross-reference line
124 -- (^X...) is found. Search is started from the beginning of the file.
125 -- If not such line is found, No_Xref_Information is raised.
126 -- If W_Lines is false, then the lines "^W" are not parsed.
127 -- If D_Lines is false, then the lines "^D" are not parsed.
128
129 ----------------
130 -- Add_Entity --
131 ----------------
132
133 procedure Add_Entity
134 (Pattern : in out Search_Pattern;
135 Entity : String;
136 Glob : Boolean := False)
137 is
138 File_Start : Natural;
139 Line_Start : Natural;
140 Col_Start : Natural;
141 Line_Num : Natural := 0;
142 Col_Num : Natural := 0;
143
144 File_Ref : File_Reference := Empty_File;
145 pragma Warnings (Off, File_Ref);
146
147 begin
148 -- Find the end of the first item in Entity (pattern or file?)
149 -- If there is no ':', we only have a pattern
150
151 File_Start := Index (Entity, ":");
152
153 -- If the regular expression is invalid, just consider it as a string
154
155 if File_Start = 0 then
156 begin
157 Pattern.Entity := Compile (Entity, Glob, False);
158 Pattern.Initialized := True;
159
160 exception
161 when Error_In_Regexp =>
162
163 -- The basic idea is to insert a \ before every character
164
165 declare
166 Tmp_Regexp : String (1 .. 2 * Entity'Length);
167 Index : Positive := 1;
168
169 begin
170 for J in Entity'Range loop
171 Tmp_Regexp (Index) := '\';
172 Tmp_Regexp (Index + 1) := Entity (J);
173 Index := Index + 2;
174 end loop;
175
176 Pattern.Entity := Compile (Tmp_Regexp, True, False);
177 Pattern.Initialized := True;
178 end;
179 end;
180
181 Set_Default_Match (True);
182 return;
183 end if;
184
185 -- If there is a dot in the pattern, then it is a file name
186
187 if (Glob and then
188 Index (Entity (Entity'First .. File_Start - 1), ".") /= 0)
189 or else
190 (not Glob
191 and then Index (Entity (Entity'First .. File_Start - 1),
192 "\.") /= 0)
193 then
194 Pattern.Entity := Compile (".*", False);
195 Pattern.Initialized := True;
196 File_Start := Entity'First;
197
198 else
199 -- If the regular expression is invalid, just consider it as a string
200
201 begin
202 Pattern.Entity :=
203 Compile (Entity (Entity'First .. File_Start - 1), Glob, False);
204 Pattern.Initialized := True;
205
206 exception
207 when Error_In_Regexp =>
208
209 -- The basic idea is to insert a \ before every character
210
211 declare
212 Tmp_Regexp : String (1 .. 2 * (File_Start - Entity'First));
213 Index : Positive := 1;
214
215 begin
216 for J in Entity'First .. File_Start - 1 loop
217 Tmp_Regexp (Index) := '\';
218 Tmp_Regexp (Index + 1) := Entity (J);
219 Index := Index + 2;
220 end loop;
221
222 Pattern.Entity := Compile (Tmp_Regexp, True, False);
223 Pattern.Initialized := True;
224 end;
225 end;
226
227 File_Start := File_Start + 1;
228 end if;
229
230 -- Parse the file name
231
232 Line_Start := Index (Entity (File_Start .. Entity'Last), ":");
233
234 -- Check if it was a disk:\directory item (for Windows)
235
236 if File_Start = Line_Start - 1
237 and then Line_Start < Entity'Last
238 and then Entity (Line_Start + 1) = '\'
239 then
240 Line_Start := Index (Entity (Line_Start + 1 .. Entity'Last), ":");
241 end if;
242
243 if Line_Start = 0 then
244 Line_Start := Entity'Length + 1;
245
246 elsif Line_Start /= Entity'Last then
247 Col_Start := Index (Entity (Line_Start + 1 .. Entity'Last), ":");
248
249 if Col_Start = 0 then
250 Col_Start := Entity'Last + 1;
251 end if;
252
253 if Col_Start > Line_Start + 1 then
254 begin
255 Line_Num := Natural'Value
256 (Entity (Line_Start + 1 .. Col_Start - 1));
257
258 exception
259 when Constraint_Error =>
260 raise Invalid_Argument;
261 end;
262 end if;
263
264 if Col_Start < Entity'Last then
265 begin
266 Col_Num := Natural'Value (Entity
267 (Col_Start + 1 .. Entity'Last));
268
269 exception
270 when Constraint_Error => raise Invalid_Argument;
271 end;
272 end if;
273 end if;
274
275 declare
276 File_Name : String := Entity (File_Start .. Line_Start - 1);
277
278 begin
279 Osint.Canonical_Case_File_Name (File_Name);
280 File_Ref := Add_To_Xref_File (File_Name, Visited => True);
281 Pattern.File_Ref := File_Ref;
282
283 Add_Line (Pattern.File_Ref, Line_Num, Col_Num);
284
285 File_Ref :=
286 Add_To_Xref_File
287 (ALI_File_Name (File_Name),
288 Visited => False,
289 Emit_Warning => True);
290 end;
291 end Add_Entity;
292
293 -------------------
294 -- Add_Xref_File --
295 -------------------
296
297 procedure Add_Xref_File (File : String) is
298 File_Ref : File_Reference := Empty_File;
299 pragma Unreferenced (File_Ref);
300
301 Iterator : Expansion_Iterator;
302
303 procedure Add_Xref_File_Internal (File : String);
304 -- Do the actual addition of the file
305
306 ----------------------------
307 -- Add_Xref_File_Internal --
308 ----------------------------
309
310 procedure Add_Xref_File_Internal (File : String) is
311 begin
312 -- Case where we have an ALI file, accept it even though this is
313 -- not official usage, since the intention is obvious
314
315 if Tail (File, 4) = "." & Osint.ALI_Suffix.all then
316 File_Ref := Add_To_Xref_File
317 (File, Visited => False, Emit_Warning => True);
318
319 -- Normal non-ali file case
320
321 else
322 File_Ref := Add_To_Xref_File (File, Visited => True);
323
324 File_Ref := Add_To_Xref_File
325 (ALI_File_Name (File),
326 Visited => False, Emit_Warning => True);
327 end if;
328 end Add_Xref_File_Internal;
329
330 -- Start of processing for Add_Xref_File
331
332 begin
333 -- Check if we need to do the expansion
334
335 if Ada.Strings.Fixed.Index (File, "*") /= 0
336 or else Ada.Strings.Fixed.Index (File, "?") /= 0
337 then
338 Start_Expansion (Iterator, File);
339
340 loop
341 declare
342 S : constant String := Expansion (Iterator);
343
344 begin
345 exit when S'Length = 0;
346 Add_Xref_File_Internal (S);
347 end;
348 end loop;
349
350 else
351 Add_Xref_File_Internal (File);
352 end if;
353 end Add_Xref_File;
354
355 -----------------------
356 -- Current_Xref_File --
357 -----------------------
358
359 function Current_Xref_File (File : ALI_File) return File_Reference is
360 begin
361 return File.X_File;
362 end Current_Xref_File;
363
364 --------------------------
365 -- Default_Project_File --
366 --------------------------
367
368 function Default_Project_File (Dir_Name : String) return String is
369 My_Dir : Dir_Type;
370 Dir_Ent : File_Name_String;
371 Last : Natural;
372
373 begin
374 Open (My_Dir, Dir_Name);
375
376 loop
377 Read (My_Dir, Dir_Ent, Last);
378 exit when Last = 0;
379
380 if Tail (Dir_Ent (1 .. Last), 4) = ".adp" then
381
382 -- The first project file found is the good one
383
384 Close (My_Dir);
385 return Dir_Ent (1 .. Last);
386 end if;
387 end loop;
388
389 Close (My_Dir);
390 return String'(1 .. 0 => ' ');
391
392 exception
393 when Directory_Error => return String'(1 .. 0 => ' ');
394 end Default_Project_File;
395
396 ---------------
397 -- File_Name --
398 ---------------
399
400 function File_Name
401 (File : ALI_File;
402 Num : Positive) return File_Reference
403 is
404 begin
405 return File.Dep.Table (Num);
406 end File_Name;
407
408 --------------------
409 -- Find_ALI_Files --
410 --------------------
411
412 procedure Find_ALI_Files is
413 My_Dir : Rec_DIR;
414 Dir_Ent : File_Name_String;
415 Last : Natural;
416
417 File_Ref : File_Reference;
418 pragma Unreferenced (File_Ref);
419
420 function Open_Next_Dir return Boolean;
421 -- Tries to open the next object directory, and return False if
422 -- the directory cannot be opened.
423
424 -------------------
425 -- Open_Next_Dir --
426 -------------------
427
428 function Open_Next_Dir return Boolean is
429 begin
430 -- Until we are able to open a new directory
431
432 loop
433 declare
434 Obj_Dir : constant String := Next_Obj_Dir;
435
436 begin
437 -- Case of no more Obj_Dir lines
438
439 if Obj_Dir'Length = 0 then
440 return False;
441 end if;
442
443 Open (My_Dir.Dir, Obj_Dir);
444 exit;
445
446 exception
447
448 -- Could not open the directory
449
450 when Directory_Error => null;
451 end;
452 end loop;
453
454 return True;
455 end Open_Next_Dir;
456
457 -- Start of processing for Find_ALI_Files
458
459 begin
460 Reset_Obj_Dir;
461
462 if Open_Next_Dir then
463 loop
464 Read (My_Dir.Dir, Dir_Ent, Last);
465
466 if Last = 0 then
467 Close (My_Dir.Dir);
468
469 if not Open_Next_Dir then
470 return;
471 end if;
472
473 elsif Last > 4
474 and then Dir_Ent (Last - 3 .. Last) = "." & Osint.ALI_Suffix.all
475 then
476 File_Ref :=
477 Add_To_Xref_File (Dir_Ent (1 .. Last), Visited => False);
478 end if;
479 end loop;
480 end if;
481 end Find_ALI_Files;
482
483 -------------------
484 -- Get_Full_Type --
485 -------------------
486
487 function Get_Full_Type (Decl : Declaration_Reference) return String is
488
489 function Param_String return String;
490 -- Return the string to display depending on whether Decl is a parameter
491
492 ------------------
493 -- Param_String --
494 ------------------
495
496 function Param_String return String is
497 begin
498 if Is_Parameter (Decl) then
499 return "parameter ";
500 else
501 return "";
502 end if;
503 end Param_String;
504
505 -- Start of processing for Get_Full_Type
506
507 begin
508 case Get_Type (Decl) is
509 when 'A' => return "array type";
510 when 'B' => return "boolean type";
511 when 'C' => return "class-wide type";
512 when 'D' => return "decimal type";
513 when 'E' => return "enumeration type";
514 when 'F' => return "float type";
515 when 'H' => return "abstract type";
516 when 'I' => return "integer type";
517 when 'M' => return "modular type";
518 when 'O' => return "fixed type";
519 when 'P' => return "access type";
520 when 'R' => return "record type";
521 when 'S' => return "string type";
522 when 'T' => return "task type";
523 when 'W' => return "protected type";
524
525 when 'a' => return Param_String & "array object";
526 when 'b' => return Param_String & "boolean object";
527 when 'c' => return Param_String & "class-wide object";
528 when 'd' => return Param_String & "decimal object";
529 when 'e' => return Param_String & "enumeration object";
530 when 'f' => return Param_String & "float object";
531 when 'i' => return Param_String & "integer object";
532 when 'j' => return Param_String & "class object";
533 when 'm' => return Param_String & "modular object";
534 when 'o' => return Param_String & "fixed object";
535 when 'p' => return Param_String & "access object";
536 when 'r' => return Param_String & "record object";
537 when 's' => return Param_String & "string object";
538 when 't' => return Param_String & "task object";
539 when 'w' => return Param_String & "protected object";
540 when 'x' => return Param_String & "abstract procedure";
541 when 'y' => return Param_String & "abstract function";
542
543 when 'h' => return "interface";
544 when 'g' => return "macro";
545 when 'G' => return "function macro";
546 when 'J' => return "class";
547 when 'K' => return "package";
548 when 'k' => return "generic package";
549 when 'L' => return "statement label";
550 when 'l' => return "loop label";
551 when 'N' => return "named number";
552 when 'n' => return "enumeration literal";
553 when 'q' => return "block label";
554 when 'Q' => return "include file";
555 when 'U' => return "procedure";
556 when 'u' => return "generic procedure";
557 when 'V' => return "function";
558 when 'v' => return "generic function";
559 when 'X' => return "exception";
560 when 'Y' => return "entry";
561
562 when '+' => return "private type";
563 when '*' => return "private variable";
564
565 -- The above should be the only possibilities, but for this kind
566 -- of informational output, we don't want to bomb if we find
567 -- something else, so just return three question marks when we
568 -- have an unknown Abbrev value
569
570 when others =>
571 if Is_Parameter (Decl) then
572 return "parameter";
573 else
574 return "??? (" & Get_Type (Decl) & ")";
575 end if;
576 end case;
577 end Get_Full_Type;
578
579 --------------------------
580 -- Skip_To_First_X_Line --
581 --------------------------
582
583 procedure Skip_To_First_X_Line
584 (File : in out ALI_File;
585 D_Lines : Boolean;
586 W_Lines : Boolean)
587 is
588 Ali : String_Access renames File.Buffer;
589 Token : Positive;
590 Ptr : Positive := Ali'First;
591 Num_Dependencies : Natural := 0;
592 File_Start : Positive;
593 File_End : Positive;
594 Gnatchop_Offset : Integer;
595 Gnatchop_Name : Positive;
596
597 File_Ref : File_Reference;
598 pragma Unreferenced (File_Ref);
599
600 begin
601 -- Read all the lines possibly processing with-clauses and dependency
602 -- information and exit on finding the first Xref line.
603 -- A fall-through of the loop means that there is no xref information
604 -- which is an error condition.
605
606 while Ali (Ptr) /= EOF loop
607 if D_Lines and then Ali (Ptr) = 'D' then
608
609 -- Found dependency information. Format looks like:
610 -- D src-nam time-stmp checksum [subunit-name] [line:file-name]
611
612 -- Skip the D and parse the filenam
613
614 Ptr := Ptr + 1;
615 Parse_Token (Ali, Ptr, Token);
616 File_Start := Token;
617 File_End := Ptr - 1;
618
619 Num_Dependencies := Num_Dependencies + 1;
620 Set_Last (File.Dep, Num_Dependencies);
621
622 Parse_Token (Ali, Ptr, Token); -- Skip time-stamp
623 Parse_Token (Ali, Ptr, Token); -- Skip checksum
624 Parse_Token (Ali, Ptr, Token); -- Read next entity on the line
625
626 if not (Ali (Token) in '0' .. '9') then
627 Parse_Token (Ali, Ptr, Token); -- Was a subunit name
628 end if;
629
630 -- Did we have a gnatchop-ed file with a pragma Source_Reference ?
631
632 Gnatchop_Offset := 0;
633
634 if Ali (Token) in '0' .. '9' then
635 Gnatchop_Name := Token;
636 while Ali (Gnatchop_Name) /= ':' loop
637 Gnatchop_Name := Gnatchop_Name + 1;
638 end loop;
639
640 Gnatchop_Offset :=
641 2 - Natural'Value (Ali (Token .. Gnatchop_Name - 1));
642 Token := Gnatchop_Name + 1;
643 end if;
644
645 File.Dep.Table (Num_Dependencies) := Add_To_Xref_File
646 (Ali (File_Start .. File_End),
647 Gnatchop_File => Ali (Token .. Ptr - 1),
648 Gnatchop_Offset => Gnatchop_Offset);
649
650 elsif W_Lines and then Ali (Ptr) = 'W' then
651
652 -- Found with-clause information. Format looks like:
653 -- "W debug%s debug.adb debug.ali"
654
655 -- Skip the W and parse the .ali filename (3rd token)
656
657 Parse_Token (Ali, Ptr, Token);
658 Parse_Token (Ali, Ptr, Token);
659 Parse_Token (Ali, Ptr, Token);
660
661 File_Ref :=
662 Add_To_Xref_File (Ali (Token .. Ptr - 1), Visited => False);
663
664 elsif Ali (Ptr) = 'X' then
665
666 -- Found a cross-referencing line - stop processing
667
668 File.Current_Line := Ptr;
669 File.Xref_Line := Ptr;
670 return;
671 end if;
672
673 Parse_EOL (Ali, Ptr);
674 end loop;
675
676 raise No_Xref_Information;
677 end Skip_To_First_X_Line;
678
679 ----------
680 -- Open --
681 ----------
682
683 procedure Open
684 (Name : String;
685 File : out ALI_File;
686 Dependencies : Boolean := False)
687 is
688 Ali : String_Access renames File.Buffer;
689 pragma Warnings (Off, Ali);
690
691 begin
692 if File.Buffer /= null then
693 Free (File.Buffer);
694 end if;
695
696 Init (File.Dep);
697
698 begin
699 Read_File (Name, Ali);
700
701 exception
702 when Ada.Text_IO.Name_Error | Ada.Text_IO.End_Error =>
703 raise No_Xref_Information;
704 end;
705
706 Skip_To_First_X_Line (File, D_Lines => True, W_Lines => Dependencies);
707 end Open;
708
709 ---------------
710 -- Parse_EOL --
711 ---------------
712
713 procedure Parse_EOL
714 (Source : not null access String;
715 Ptr : in out Positive;
716 Skip_Continuation_Line : Boolean := False)
717 is
718 begin
719 loop
720 -- Skip to end of line
721
722 while Source (Ptr) /= ASCII.CR and then Source (Ptr) /= ASCII.LF
723 and then Source (Ptr) /= EOF
724 loop
725 Ptr := Ptr + 1;
726 end loop;
727
728 -- Skip CR or LF if not at end of file
729
730 if Source (Ptr) /= EOF then
731 Ptr := Ptr + 1;
732 end if;
733
734 -- Skip past CR/LF or LF/CR combination
735
736 if (Source (Ptr) = ASCII.CR or else Source (Ptr) = ASCII.LF)
737 and then Source (Ptr) /= Source (Ptr - 1)
738 then
739 Ptr := Ptr + 1;
740 end if;
741
742 exit when not Skip_Continuation_Line or else Source (Ptr) /= '.';
743 end loop;
744 end Parse_EOL;
745
746 ---------------------------
747 -- Parse_Identifier_Info --
748 ---------------------------
749
750 procedure Parse_Identifier_Info
751 (Pattern : Search_Pattern;
752 File : in out ALI_File;
753 Local_Symbols : Boolean;
754 Der_Info : Boolean := False;
755 Type_Tree : Boolean := False;
756 Wide_Search : Boolean := True;
757 Labels_As_Ref : Boolean := True)
758 is
759 Ptr : Positive renames File.Current_Line;
760 Ali : String_Access renames File.Buffer;
761
762 E_Line : Natural; -- Line number of current entity
763 E_Col : Natural; -- Column number of current entity
764 E_Type : Character; -- Type of current entity
765 E_Name : Positive; -- Pointer to begin of entity name
766 E_Global : Boolean; -- True iff entity is global
767
768 R_Line : Natural; -- Line number of current reference
769 R_Col : Natural; -- Column number of current reference
770 R_Type : Character; -- Type of current reference
771
772 Decl_Ref : Declaration_Reference;
773 File_Ref : File_Reference := Current_Xref_File (File);
774
775 function Get_Symbol_Name (Eun, Line, Col : Natural) return String;
776 -- Returns the symbol name for the entity defined at the specified
777 -- line and column in the dependent unit number Eun. For this we need
778 -- to parse the ali file again because the parent entity is not in
779 -- the declaration table if it did not match the search pattern.
780
781 procedure Skip_To_Matching_Closing_Bracket;
782 -- When Ptr points to an opening square bracket, moves it to the
783 -- character following the matching closing bracket
784
785 ---------------------
786 -- Get_Symbol_Name --
787 ---------------------
788
789 function Get_Symbol_Name (Eun, Line, Col : Natural) return String is
790 Ptr : Positive := 1;
791 E_Eun : Positive; -- Unit number of current entity
792 E_Line : Natural; -- Line number of current entity
793 E_Col : Natural; -- Column number of current entity
794 E_Name : Positive; -- Pointer to begin of entity name
795
796 begin
797 -- Look for the X lines corresponding to unit Eun
798
799 loop
800 if Ali (Ptr) = 'X' then
801 Ptr := Ptr + 1;
802 Parse_Number (Ali, Ptr, E_Eun);
803 exit when E_Eun = Eun;
804 end if;
805
806 Parse_EOL (Ali, Ptr, Skip_Continuation_Line => True);
807 end loop;
808
809 -- Here we are in the right Ali section, we now look for the entity
810 -- declared at position (Line, Col).
811
812 loop
813 Parse_Number (Ali, Ptr, E_Line);
814 exit when Ali (Ptr) = EOF;
815 Ptr := Ptr + 1;
816 Parse_Number (Ali, Ptr, E_Col);
817 exit when Ali (Ptr) = EOF;
818 Ptr := Ptr + 1;
819
820 if Line = E_Line and then Col = E_Col then
821 Parse_Token (Ali, Ptr, E_Name);
822 return Ali (E_Name .. Ptr - 1);
823 end if;
824
825 Parse_EOL (Ali, Ptr, Skip_Continuation_Line => True);
826 exit when Ali (Ptr) = EOF;
827 end loop;
828
829 -- We were not able to find the symbol, this should not happen but
830 -- since we don't want to stop here we return a string of three
831 -- question marks as the symbol name.
832
833 return "???";
834 end Get_Symbol_Name;
835
836 --------------------------------------
837 -- Skip_To_Matching_Closing_Bracket --
838 --------------------------------------
839
840 procedure Skip_To_Matching_Closing_Bracket is
841 Num_Brackets : Natural;
842
843 begin
844 Num_Brackets := 1;
845 while Num_Brackets /= 0 loop
846 Ptr := Ptr + 1;
847 if Ali (Ptr) = '[' then
848 Num_Brackets := Num_Brackets + 1;
849 elsif Ali (Ptr) = ']' then
850 Num_Brackets := Num_Brackets - 1;
851 end if;
852 end loop;
853
854 Ptr := Ptr + 1;
855 end Skip_To_Matching_Closing_Bracket;
856
857 -- Start of processing for Parse_Identifier_Info
858
859 begin
860 -- The identifier info looks like:
861 -- "38U9*Debug 12|36r6 36r19"
862
863 -- Extract the line, column and entity name information
864
865 Parse_Number (Ali, Ptr, E_Line);
866
867 if Ali (Ptr) > ' ' then
868 E_Type := Ali (Ptr);
869 Ptr := Ptr + 1;
870 end if;
871
872 -- Ignore some of the entities (labels,...)
873
874 case E_Type is
875 when 'l' | 'L' | 'q' =>
876 Parse_EOL (Ali, Ptr, Skip_Continuation_Line => True);
877 return;
878
879 when others =>
880 null;
881 end case;
882
883 Parse_Number (Ali, Ptr, E_Col);
884
885 E_Global := False;
886 if Ali (Ptr) >= ' ' then
887 E_Global := (Ali (Ptr) = '*');
888 Ptr := Ptr + 1;
889 end if;
890
891 Parse_Token (Ali, Ptr, E_Name);
892
893 -- Exit if the symbol does not match or if we have a local symbol and we
894 -- do not want it or if the file is unknown.
895
896 if File.X_File = Empty_File then
897 return;
898 end if;
899
900 if (not Local_Symbols and not E_Global)
901 or else (Pattern.Initialized
902 and then not Match (Ali (E_Name .. Ptr - 1), Pattern.Entity))
903 or else (E_Name >= Ptr)
904 then
905 Decl_Ref := Add_Declaration
906 (File.X_File, Ali (E_Name .. Ptr - 1), E_Line, E_Col, E_Type,
907 Remove_Only => True);
908 Parse_EOL (Ali, Ptr, Skip_Continuation_Line => True);
909 return;
910 end if;
911
912 -- Insert the declaration in the table
913
914 Decl_Ref := Add_Declaration
915 (File.X_File, Ali (E_Name .. Ptr - 1), E_Line, E_Col, E_Type);
916
917 if Ali (Ptr) = '[' then
918 Skip_To_Matching_Closing_Bracket;
919 end if;
920
921 -- Skip any renaming indication
922
923 if Ali (Ptr) = '=' then
924 declare
925 P_Line, P_Column : Natural;
926 pragma Warnings (Off, P_Line);
927 pragma Warnings (Off, P_Column);
928 begin
929 Ptr := Ptr + 1;
930 Parse_Number (Ali, Ptr, P_Line);
931 Ptr := Ptr + 1;
932 Parse_Number (Ali, Ptr, P_Column);
933 end;
934 end if;
935
936 while Ptr <= Ali'Last
937 and then (Ali (Ptr) = '<'
938 or else Ali (Ptr) = '('
939 or else Ali (Ptr) = '{')
940 loop
941 -- Here we have a type derivation information. The format is
942 -- <3|12I45> which means that the current entity is derived from the
943 -- type defined in unit number 3, line 12 column 45. The pipe and
944 -- unit number is optional. It is specified only if the parent type
945 -- is not defined in the current unit.
946
947 -- We also have the format for generic instantiations, as in
948 -- 7a5*Uid(3|5I8[4|2]) 2|4r74
949
950 -- We could also have something like
951 -- 16I9*I<integer>
952 -- that indicates that I derives from the predefined type integer.
953
954 Ptr := Ptr + 1;
955
956 if Ali (Ptr) in '0' .. '9' then
957 Parse_Derived_Info : declare
958 P_Line : Natural; -- parent entity line
959 P_Column : Natural; -- parent entity column
960 P_Eun : Positive; -- parent entity file number
961
962 begin
963 Parse_Number (Ali, Ptr, P_Line);
964
965 -- If we have a pipe then the first number was the unit number
966
967 if Ali (Ptr) = '|' then
968 P_Eun := P_Line;
969 Ptr := Ptr + 1;
970
971 -- Now we have the line number
972
973 Parse_Number (Ali, Ptr, P_Line);
974
975 else
976 -- We don't have a unit number specified, so we set P_Eun to
977 -- the current unit.
978
979 for K in Dependencies_Tables.First .. Last (File.Dep) loop
980 P_Eun := K;
981 exit when File.Dep.Table (K) = File_Ref;
982 end loop;
983 end if;
984
985 -- Then parse the type and column number
986
987 Ptr := Ptr + 1;
988 Parse_Number (Ali, Ptr, P_Column);
989
990 -- Skip the information for generics instantiations
991
992 if Ali (Ptr) = '[' then
993 Skip_To_Matching_Closing_Bracket;
994 end if;
995
996 -- Skip '>', or ')' or '>'
997
998 Ptr := Ptr + 1;
999
1000 -- The derived info is needed only is the derived info mode is
1001 -- on or if we want to output the type hierarchy
1002
1003 if Der_Info or else Type_Tree then
1004 declare
1005 Symbol : constant String :=
1006 Get_Symbol_Name (P_Eun, P_Line, P_Column);
1007 begin
1008 if Symbol /= "???" then
1009 Add_Parent
1010 (Decl_Ref,
1011 Symbol,
1012 P_Line,
1013 P_Column,
1014 File.Dep.Table (P_Eun));
1015 end if;
1016 end;
1017 end if;
1018
1019 if Type_Tree
1020 and then (Pattern.File_Ref = Empty_File
1021 or else
1022 Pattern.File_Ref = Current_Xref_File (File))
1023 then
1024 Search_Parent_Tree : declare
1025 Pattern : Search_Pattern; -- Parent type pattern
1026 File_Pos_Backup : Positive;
1027
1028 begin
1029 Add_Entity
1030 (Pattern,
1031 Get_Symbol_Name (P_Eun, P_Line, P_Column)
1032 & ':' & Get_Gnatchop_File (File.Dep.Table (P_Eun))
1033 & ':' & Get_Line (Get_Parent (Decl_Ref))
1034 & ':' & Get_Column (Get_Parent (Decl_Ref)),
1035 False);
1036
1037 -- No default match is needed to look for the parent type
1038 -- since we are using the fully qualified symbol name:
1039 -- symbol:file:line:column
1040
1041 Set_Default_Match (False);
1042
1043 -- The parent hierarchy is defined in the same unit as
1044 -- the derived type. So we want to revisit the unit.
1045
1046 File_Pos_Backup := File.Current_Line;
1047
1048 Skip_To_First_X_Line
1049 (File, D_Lines => False, W_Lines => False);
1050
1051 while File.Buffer (File.Current_Line) /= EOF loop
1052 Parse_X_Filename (File);
1053 Parse_Identifier_Info
1054 (Pattern => Pattern,
1055 File => File,
1056 Local_Symbols => False,
1057 Der_Info => Der_Info,
1058 Type_Tree => True,
1059 Wide_Search => False,
1060 Labels_As_Ref => Labels_As_Ref);
1061 end loop;
1062
1063 File.Current_Line := File_Pos_Backup;
1064 end Search_Parent_Tree;
1065 end if;
1066 end Parse_Derived_Info;
1067
1068 else
1069 while Ali (Ptr) /= '>'
1070 and then Ali (Ptr) /= ')'
1071 and then Ali (Ptr) /= '}'
1072 loop
1073 Ptr := Ptr + 1;
1074 end loop;
1075 Ptr := Ptr + 1;
1076 end if;
1077 end loop;
1078
1079 -- To find the body, we will have to parse the file too
1080
1081 if Wide_Search then
1082 declare
1083 File_Ref : File_Reference;
1084 pragma Unreferenced (File_Ref);
1085 File_Name : constant String := Get_Gnatchop_File (File.X_File);
1086 begin
1087 File_Ref := Add_To_Xref_File (ALI_File_Name (File_Name), False);
1088 end;
1089 end if;
1090
1091 -- Parse references to this entity.
1092 -- Ptr points to next reference with leading blanks
1093
1094 loop
1095 -- Process references on current line
1096
1097 while Ali (Ptr) = ' ' or else Ali (Ptr) = ASCII.HT loop
1098
1099 -- For every reference read the line, type and column,
1100 -- optionally preceded by a file number and a pipe symbol.
1101
1102 Parse_Number (Ali, Ptr, R_Line);
1103
1104 if Ali (Ptr) = Pipe then
1105 Ptr := Ptr + 1;
1106 File_Ref := File_Name (File, R_Line);
1107
1108 Parse_Number (Ali, Ptr, R_Line);
1109 end if;
1110
1111 if Ali (Ptr) > ' ' then
1112 R_Type := Ali (Ptr);
1113 Ptr := Ptr + 1;
1114 end if;
1115
1116 -- Imported entities may have an indication specifying information
1117 -- about the corresponding external name:
1118 -- 5U14*Foo2 5>20 6b<c,myfoo2>22 # Imported entity
1119 -- 5U14*Foo2 5>20 6i<c,myfoo2>22 # Exported entity
1120
1121 if (R_Type = 'b' or else R_Type = 'i')
1122 and then Ali (Ptr) = '<'
1123 then
1124 while Ptr <= Ali'Last
1125 and then Ali (Ptr) /= '>'
1126 loop
1127 Ptr := Ptr + 1;
1128 end loop;
1129 Ptr := Ptr + 1;
1130 end if;
1131
1132 Parse_Number (Ali, Ptr, R_Col);
1133
1134 -- Insert the reference or body in the table
1135
1136 Add_Reference
1137 (Decl_Ref, File_Ref, R_Line, R_Col, R_Type, Labels_As_Ref);
1138
1139 -- Skip generic information, if any
1140
1141 if Ali (Ptr) = '[' then
1142 declare
1143 Num_Nested : Integer := 1;
1144
1145 begin
1146 Ptr := Ptr + 1;
1147 while Num_Nested /= 0 loop
1148 if Ali (Ptr) = ']' then
1149 Num_Nested := Num_Nested - 1;
1150 elsif Ali (Ptr) = '[' then
1151 Num_Nested := Num_Nested + 1;
1152 end if;
1153
1154 Ptr := Ptr + 1;
1155 end loop;
1156 end;
1157 end if;
1158
1159 end loop;
1160
1161 Parse_EOL (Ali, Ptr);
1162
1163 -- Loop until new line is no continuation line
1164
1165 exit when Ali (Ptr) /= '.';
1166 Ptr := Ptr + 1;
1167 end loop;
1168 end Parse_Identifier_Info;
1169
1170 ------------------
1171 -- Parse_Number --
1172 ------------------
1173
1174 procedure Parse_Number
1175 (Source : not null access String;
1176 Ptr : in out Positive;
1177 Number : out Natural)
1178 is
1179 begin
1180 -- Skip separators
1181
1182 while Source (Ptr) = ' ' or else Source (Ptr) = ASCII.HT loop
1183 Ptr := Ptr + 1;
1184 end loop;
1185
1186 Number := 0;
1187 while Source (Ptr) in '0' .. '9' loop
1188 Number :=
1189 10 * Number + (Character'Pos (Source (Ptr)) - Character'Pos ('0'));
1190 Ptr := Ptr + 1;
1191 end loop;
1192 end Parse_Number;
1193
1194 -----------------
1195 -- Parse_Token --
1196 -----------------
1197
1198 procedure Parse_Token
1199 (Source : not null access String;
1200 Ptr : in out Positive;
1201 Token_Ptr : out Positive)
1202 is
1203 In_Quotes : Character := ASCII.NUL;
1204
1205 begin
1206 -- Skip separators
1207
1208 while Source (Ptr) = ' ' or else Source (Ptr) = ASCII.HT loop
1209 Ptr := Ptr + 1;
1210 end loop;
1211
1212 Token_Ptr := Ptr;
1213
1214 -- Find end-of-token
1215
1216 while (In_Quotes /= ASCII.NUL or else
1217 not (Source (Ptr) = ' '
1218 or else Source (Ptr) = ASCII.HT
1219 or else Source (Ptr) = '<'
1220 or else Source (Ptr) = '{'
1221 or else Source (Ptr) = '['
1222 or else Source (Ptr) = '='
1223 or else Source (Ptr) = '('))
1224 and then Source (Ptr) >= ' '
1225 loop
1226 -- Double-quotes are used for operators
1227 -- Simple-quotes are used for character constants, for instance when
1228 -- they are found in an enumeration type "type A is ('+', '-');"
1229
1230 case Source (Ptr) is
1231 when '"' | ''' =>
1232 if In_Quotes = Source (Ptr) then
1233 In_Quotes := ASCII.NUL;
1234 elsif In_Quotes = ASCII.NUL then
1235 In_Quotes := Source (Ptr);
1236 end if;
1237
1238 when others =>
1239 null;
1240 end case;
1241
1242 Ptr := Ptr + 1;
1243 end loop;
1244 end Parse_Token;
1245
1246 ----------------------
1247 -- Parse_X_Filename --
1248 ----------------------
1249
1250 procedure Parse_X_Filename (File : in out ALI_File) is
1251 Ali : String_Access renames File.Buffer;
1252 Ptr : Positive renames File.Current_Line;
1253 File_Nr : Natural;
1254
1255 begin
1256 while Ali (Ptr) = 'X' loop
1257
1258 -- The current line is the start of a new Xref file section,
1259 -- whose format looks like:
1260
1261 -- " X 1 debug.ads"
1262
1263 -- Skip the X and read the file number for the new X_File
1264
1265 Ptr := Ptr + 1;
1266 Parse_Number (Ali, Ptr, File_Nr);
1267
1268 -- If the referenced file is unknown, we simply ignore it
1269
1270 if File_Nr in Dependencies_Tables.First .. Last (File.Dep) then
1271 File.X_File := File.Dep.Table (File_Nr);
1272 else
1273 File.X_File := Empty_File;
1274 end if;
1275
1276 Parse_EOL (Ali, Ptr);
1277 end loop;
1278 end Parse_X_Filename;
1279
1280 --------------------
1281 -- Print_Gnatfind --
1282 --------------------
1283
1284 procedure Print_Gnatfind
1285 (References : Boolean;
1286 Full_Path_Name : Boolean)
1287 is
1288 Decls : constant Declaration_Array_Access := Get_Declarations;
1289 Decl : Declaration_Reference;
1290 Arr : Reference_Array_Access;
1291
1292 procedure Print_Ref
1293 (Ref : Reference;
1294 Msg : String := " ");
1295 -- Print a reference, according to the extended tag of the output
1296
1297 ---------------
1298 -- Print_Ref --
1299 ---------------
1300
1301 procedure Print_Ref
1302 (Ref : Reference;
1303 Msg : String := " ")
1304 is
1305 F : String_Access :=
1306 Osint.To_Host_File_Spec
1307 (Get_Gnatchop_File (Ref, Full_Path_Name));
1308
1309 Buffer : constant String :=
1310 F.all &
1311 ":" & Get_Line (Ref) &
1312 ":" & Get_Column (Ref) &
1313 ": ";
1314
1315 Num_Blanks : Integer := Longest_File_Name + 10 - Buffer'Length;
1316
1317 begin
1318 Free (F);
1319 Num_Blanks := Integer'Max (0, Num_Blanks);
1320 Write_Line
1321 (Buffer
1322 & String'(1 .. Num_Blanks => ' ')
1323 & Msg & " " & Get_Symbol (Decl));
1324
1325 if Get_Source_Line (Ref)'Length /= 0 then
1326 Write_Line (" " & Get_Source_Line (Ref));
1327 end if;
1328 end Print_Ref;
1329
1330 -- Start of processing for Print_Gnatfind
1331
1332 begin
1333 for D in Decls'Range loop
1334 Decl := Decls (D);
1335
1336 if Match (Decl) then
1337
1338 -- Output the declaration
1339
1340 declare
1341 Parent : constant Declaration_Reference := Get_Parent (Decl);
1342
1343 F : String_Access :=
1344 Osint.To_Host_File_Spec
1345 (Get_Gnatchop_File (Decl, Full_Path_Name));
1346
1347 Buffer : constant String :=
1348 F.all &
1349 ":" & Get_Line (Decl) &
1350 ":" & Get_Column (Decl) &
1351 ": ";
1352
1353 Num_Blanks : Integer := Longest_File_Name + 10 - Buffer'Length;
1354
1355 begin
1356 Free (F);
1357 Num_Blanks := Integer'Max (0, Num_Blanks);
1358 Write_Line
1359 (Buffer & String'(1 .. Num_Blanks => ' ')
1360 & "(spec) " & Get_Symbol (Decl));
1361
1362 if Parent /= Empty_Declaration then
1363 F := Osint.To_Host_File_Spec (Get_Gnatchop_File (Parent));
1364 Write_Line
1365 (Buffer & String'(1 .. Num_Blanks => ' ')
1366 & " derived from " & Get_Symbol (Parent)
1367 & " ("
1368 & F.all
1369 & ':' & Get_Line (Parent)
1370 & ':' & Get_Column (Parent) & ')');
1371 Free (F);
1372 end if;
1373 end;
1374
1375 if Get_Source_Line (Decl)'Length /= 0 then
1376 Write_Line (" " & Get_Source_Line (Decl));
1377 end if;
1378
1379 -- Output the body (sorted)
1380
1381 Arr := Get_References (Decl, Get_Bodies => True);
1382
1383 for R in Arr'Range loop
1384 Print_Ref (Arr (R), "(body)");
1385 end loop;
1386
1387 Free (Arr);
1388
1389 if References then
1390 Arr := Get_References
1391 (Decl, Get_Writes => True, Get_Reads => True);
1392
1393 for R in Arr'Range loop
1394 Print_Ref (Arr (R));
1395 end loop;
1396
1397 Free (Arr);
1398 end if;
1399 end if;
1400 end loop;
1401 end Print_Gnatfind;
1402
1403 ------------------
1404 -- Print_Unused --
1405 ------------------
1406
1407 procedure Print_Unused (Full_Path_Name : Boolean) is
1408 Decls : constant Declaration_Array_Access := Get_Declarations;
1409 Decl : Declaration_Reference;
1410 Arr : Reference_Array_Access;
1411 F : String_Access;
1412
1413 begin
1414 for D in Decls'Range loop
1415 Decl := Decls (D);
1416
1417 if References_Count
1418 (Decl, Get_Reads => True, Get_Writes => True) = 0
1419 then
1420 F := Osint.To_Host_File_Spec
1421 (Get_Gnatchop_File (Decl, Full_Path_Name));
1422 Write_Str (Get_Symbol (Decl)
1423 & " ("
1424 & Get_Full_Type (Decl)
1425 & ") "
1426 & F.all
1427 & ':'
1428 & Get_Line (Decl)
1429 & ':'
1430 & Get_Column (Decl));
1431 Free (F);
1432
1433 -- Print the body if any
1434
1435 Arr := Get_References (Decl, Get_Bodies => True);
1436
1437 for R in Arr'Range loop
1438 F := Osint.To_Host_File_Spec
1439 (Get_Gnatchop_File (Arr (R), Full_Path_Name));
1440 Write_Str (' '
1441 & F.all
1442 & ':' & Get_Line (Arr (R))
1443 & ':' & Get_Column (Arr (R)));
1444 Free (F);
1445 end loop;
1446
1447 Write_Eol;
1448 Free (Arr);
1449 end if;
1450 end loop;
1451 end Print_Unused;
1452
1453 --------------
1454 -- Print_Vi --
1455 --------------
1456
1457 procedure Print_Vi (Full_Path_Name : Boolean) is
1458 Tab : constant Character := ASCII.HT;
1459 Decls : constant Declaration_Array_Access :=
1460 Get_Declarations (Sorted => False);
1461 Decl : Declaration_Reference;
1462 Arr : Reference_Array_Access;
1463 F : String_Access;
1464
1465 begin
1466 for D in Decls'Range loop
1467 Decl := Decls (D);
1468
1469 F := Osint.To_Host_File_Spec (Get_File (Decl, Full_Path_Name));
1470 Write_Line (Get_Symbol (Decl) & Tab & F.all & Tab & Get_Line (Decl));
1471 Free (F);
1472
1473 -- Print the body if any
1474
1475 Arr := Get_References (Decl, Get_Bodies => True);
1476
1477 for R in Arr'Range loop
1478 F := Osint.To_Host_File_Spec (Get_File (Arr (R), Full_Path_Name));
1479 Write_Line
1480 (Get_Symbol (Decl) & Tab & F.all & Tab & Get_Line (Arr (R)));
1481 Free (F);
1482 end loop;
1483
1484 Free (Arr);
1485
1486 -- Print the modifications
1487
1488 Arr := Get_References (Decl, Get_Writes => True, Get_Reads => True);
1489
1490 for R in Arr'Range loop
1491 F := Osint.To_Host_File_Spec (Get_File (Arr (R), Full_Path_Name));
1492 Write_Line
1493 (Get_Symbol (Decl) & Tab & F.all & Tab & Get_Line (Arr (R)));
1494 Free (F);
1495 end loop;
1496
1497 Free (Arr);
1498 end loop;
1499 end Print_Vi;
1500
1501 ----------------
1502 -- Print_Xref --
1503 ----------------
1504
1505 procedure Print_Xref (Full_Path_Name : Boolean) is
1506 Decls : constant Declaration_Array_Access := Get_Declarations;
1507 Decl : Declaration_Reference;
1508
1509 Margin : constant := 10;
1510 -- Column where file names start
1511
1512 procedure New_Line80;
1513 -- Go to start of new line
1514
1515 procedure Print80 (S : String);
1516 -- Print the text, respecting the 80 columns rule
1517
1518 procedure Print_Ref (Line, Column : String);
1519 -- The beginning of the output is aligned on a column multiple of 9
1520
1521 procedure Print_List
1522 (Decl : Declaration_Reference;
1523 Msg : String;
1524 Get_Reads : Boolean := False;
1525 Get_Writes : Boolean := False;
1526 Get_Bodies : Boolean := False);
1527 -- Print a list of references. If the list is not empty, Msg will
1528 -- be printed prior to the list.
1529
1530 ----------------
1531 -- New_Line80 --
1532 ----------------
1533
1534 procedure New_Line80 is
1535 begin
1536 Write_Eol;
1537 Write_Str (String'(1 .. Margin - 1 => ' '));
1538 end New_Line80;
1539
1540 -------------
1541 -- Print80 --
1542 -------------
1543
1544 procedure Print80 (S : String) is
1545 Align : Natural := Margin - (Integer (Column) mod Margin);
1546
1547 begin
1548 if Align = Margin then
1549 Align := 0;
1550 end if;
1551
1552 Write_Str (String'(1 .. Align => ' ') & S);
1553 end Print80;
1554
1555 ---------------
1556 -- Print_Ref --
1557 ---------------
1558
1559 procedure Print_Ref (Line, Column : String) is
1560 Line_Align : constant Integer := 4 - Line'Length;
1561
1562 S : constant String := String'(1 .. Line_Align => ' ')
1563 & Line & ':' & Column;
1564
1565 Align : Natural := Margin - (Integer (Output.Column) mod Margin);
1566
1567 begin
1568 if Align = Margin then
1569 Align := 0;
1570 end if;
1571
1572 if Integer (Output.Column) + Align + S'Length > 79 then
1573 New_Line80;
1574 Align := 0;
1575 end if;
1576
1577 Write_Str (String'(1 .. Align => ' ') & S);
1578 end Print_Ref;
1579
1580 ----------------
1581 -- Print_List --
1582 ----------------
1583
1584 procedure Print_List
1585 (Decl : Declaration_Reference;
1586 Msg : String;
1587 Get_Reads : Boolean := False;
1588 Get_Writes : Boolean := False;
1589 Get_Bodies : Boolean := False)
1590 is
1591 Arr : Reference_Array_Access :=
1592 Get_References
1593 (Decl,
1594 Get_Writes => Get_Writes,
1595 Get_Reads => Get_Reads,
1596 Get_Bodies => Get_Bodies);
1597 File : File_Reference := Empty_File;
1598 F : String_Access;
1599
1600 begin
1601 if Arr'Length /= 0 then
1602 Write_Eol;
1603 Write_Str (Msg);
1604 end if;
1605
1606 for R in Arr'Range loop
1607 if Get_File_Ref (Arr (R)) /= File then
1608 if File /= Empty_File then
1609 New_Line80;
1610 end if;
1611
1612 File := Get_File_Ref (Arr (R));
1613 F := Osint.To_Host_File_Spec
1614 (Get_Gnatchop_File (Arr (R), Full_Path_Name));
1615
1616 if F = null then
1617 Write_Str ("<unknown> ");
1618 else
1619 Write_Str (F.all & ' ');
1620 Free (F);
1621 end if;
1622 end if;
1623
1624 Print_Ref (Get_Line (Arr (R)), Get_Column (Arr (R)));
1625 end loop;
1626
1627 Free (Arr);
1628 end Print_List;
1629
1630 F : String_Access;
1631
1632 -- Start of processing for Print_Xref
1633
1634 begin
1635 for D in Decls'Range loop
1636 Decl := Decls (D);
1637
1638 Write_Str (Get_Symbol (Decl));
1639
1640 -- Put the declaration type in column Type_Position, but if the
1641 -- declaration name is too long, put at least one space between its
1642 -- name and its type.
1643
1644 while Column < Type_Position - 1 loop
1645 Write_Char (' ');
1646 end loop;
1647
1648 Write_Char (' ');
1649
1650 Write_Line (Get_Full_Type (Decl));
1651
1652 Write_Parent_Info : declare
1653 Parent : constant Declaration_Reference := Get_Parent (Decl);
1654
1655 begin
1656 if Parent /= Empty_Declaration then
1657 Write_Str (" Ptype: ");
1658 F := Osint.To_Host_File_Spec (Get_Gnatchop_File (Parent));
1659 Print80 (F.all);
1660 Free (F);
1661 Print_Ref (Get_Line (Parent), Get_Column (Parent));
1662 Print80 (" " & Get_Symbol (Parent));
1663 Write_Eol;
1664 end if;
1665 end Write_Parent_Info;
1666
1667 Write_Str (" Decl: ");
1668 F := Osint.To_Host_File_Spec
1669 (Get_Gnatchop_File (Decl, Full_Path_Name));
1670
1671 if F = null then
1672 Print80 ("<unknown> ");
1673 else
1674 Print80 (F.all & ' ');
1675 Free (F);
1676 end if;
1677
1678 Print_Ref (Get_Line (Decl), Get_Column (Decl));
1679
1680 Print_List
1681 (Decl, " Body: ", Get_Bodies => True);
1682 Print_List
1683 (Decl, " Modi: ", Get_Writes => True);
1684 Print_List
1685 (Decl, " Ref: ", Get_Reads => True);
1686 Write_Eol;
1687 end loop;
1688 end Print_Xref;
1689
1690 ------------
1691 -- Search --
1692 ------------
1693
1694 procedure Search
1695 (Pattern : Search_Pattern;
1696 Local_Symbols : Boolean;
1697 Wide_Search : Boolean;
1698 Read_Only : Boolean;
1699 Der_Info : Boolean;
1700 Type_Tree : Boolean)
1701 is
1702 type String_Access is access String;
1703 procedure Free is new Unchecked_Deallocation (String, String_Access);
1704
1705 ALIfile : ALI_File;
1706 File_Ref : File_Reference;
1707 Strip_Num : Natural := 0;
1708 Ali_Name : String_Access;
1709
1710 begin
1711 -- If we want all the .ali files, then find them
1712
1713 if Wide_Search then
1714 Find_ALI_Files;
1715 end if;
1716
1717 loop
1718 -- Get the next unread ali file
1719
1720 File_Ref := Next_Unvisited_File;
1721
1722 exit when File_Ref = Empty_File;
1723
1724 -- Find the ALI file to use. Most of the time, it will be the unit
1725 -- name, with a different extension. However, when dealing with
1726 -- separates the ALI file is in fact the parent's ALI file (and this
1727 -- is recursive, in case the parent itself is a separate).
1728
1729 Strip_Num := 0;
1730 loop
1731 Free (Ali_Name);
1732 Ali_Name := new String'
1733 (Get_File (File_Ref, With_Dir => True, Strip => Strip_Num));
1734
1735 -- Stripped too many things...
1736
1737 if Ali_Name.all = "" then
1738 if Get_Emit_Warning (File_Ref) then
1739 Set_Standard_Error;
1740 Write_Line
1741 ("warning : file " & Get_File (File_Ref, With_Dir => True)
1742 & " not found");
1743 Set_Standard_Output;
1744 end if;
1745 Free (Ali_Name);
1746 exit;
1747
1748 -- If not found, try the parent's ALI file (this is needed for
1749 -- separate units and subprograms).
1750
1751 -- Reset the cached directory first, in case the separate's
1752 -- ALI file is not in the same directory.
1753
1754 elsif not File_Exists (Ali_Name.all) then
1755 Strip_Num := Strip_Num + 1;
1756 Reset_Directory (File_Ref);
1757
1758 -- Else we finally found it
1759
1760 else
1761 exit;
1762 end if;
1763 end loop;
1764
1765 -- If we had to get the parent's ALI, insert it in the list as usual.
1766 -- This is to avoid parsing it twice in case it has already been
1767 -- parsed.
1768
1769 if Ali_Name /= null and then Strip_Num /= 0 then
1770 File_Ref := Add_To_Xref_File
1771 (File_Name => Ali_Name.all,
1772 Visited => False);
1773
1774 -- Now that we have a file name, parse it to find any reference to
1775 -- the entity.
1776
1777 elsif Ali_Name /= null
1778 and then (Read_Only or else Is_Writable_File (Ali_Name.all))
1779 then
1780 begin
1781 Open (Ali_Name.all, ALIfile);
1782
1783 -- The cross-reference section in the ALI file may be followed
1784 -- by other sections, which can be identified by the starting
1785 -- character of every line, which should neither be 'X' nor a
1786 -- figure in '1' .. '9'.
1787
1788 -- The loop tests below also take into account the end-of-file
1789 -- possibility.
1790
1791 while ALIfile.Buffer (ALIfile.Current_Line) = 'X' loop
1792 Parse_X_Filename (ALIfile);
1793
1794 while ALIfile.Buffer (ALIfile.Current_Line) in '1' .. '9'
1795 loop
1796 Parse_Identifier_Info
1797 (Pattern, ALIfile, Local_Symbols, Der_Info, Type_Tree,
1798 Wide_Search, Labels_As_Ref => True);
1799 end loop;
1800 end loop;
1801
1802 exception
1803 when No_Xref_Information =>
1804 if Get_Emit_Warning (File_Ref) then
1805 Set_Standard_Error;
1806 Write_Line
1807 ("warning : No cross-referencing information in "
1808 & Ali_Name.all);
1809 Set_Standard_Output;
1810 end if;
1811 end;
1812 end if;
1813 end loop;
1814
1815 Free (Ali_Name);
1816 end Search;
1817
1818 -----------------
1819 -- Search_Xref --
1820 -----------------
1821
1822 procedure Search_Xref
1823 (Local_Symbols : Boolean;
1824 Read_Only : Boolean;
1825 Der_Info : Boolean)
1826 is
1827 ALIfile : ALI_File;
1828 File_Ref : File_Reference;
1829 Null_Pattern : Search_Pattern;
1830
1831 begin
1832 Null_Pattern.Initialized := False;
1833
1834 loop
1835 -- Find the next unvisited file
1836
1837 File_Ref := Next_Unvisited_File;
1838 exit when File_Ref = Empty_File;
1839
1840 -- Search the object directories for the .ali file
1841
1842 declare
1843 F : constant String := Get_File (File_Ref, With_Dir => True);
1844
1845 begin
1846 if Read_Only or else Is_Writable_File (F) then
1847 Open (F, ALIfile, True);
1848
1849 -- The cross-reference section in the ALI file may be followed
1850 -- by other sections, which can be identified by the starting
1851 -- character of every line, which should neither be 'X' nor a
1852 -- figure in '1' .. '9'.
1853
1854 -- The loop tests below also take into account the end-of-file
1855 -- possibility.
1856
1857 while ALIfile.Buffer (ALIfile.Current_Line) = 'X' loop
1858 Parse_X_Filename (ALIfile);
1859
1860 while ALIfile.Buffer (ALIfile.Current_Line) in '1' .. '9'
1861 loop
1862 Parse_Identifier_Info
1863 (Null_Pattern, ALIfile, Local_Symbols, Der_Info,
1864 Labels_As_Ref => False);
1865 end loop;
1866 end loop;
1867 end if;
1868
1869 exception
1870 when No_Xref_Information => null;
1871 end;
1872 end loop;
1873 end Search_Xref;
1874
1875 end Xref_Lib;