summaryrefslogtreecommitdiff
path: root/gcc/ada/xr_tabls.ads
blob: 2b19944e7b453b7bee81c57d21cf3223086ce600 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
------------------------------------------------------------------------------
--                                                                          --
--                         GNAT COMPILER COMPONENTS                         --
--                                                                          --
--                             X R  _ T A B L S                             --
--                                                                          --
--                                 S p e c                                  --
--                                                                          --
--         Copyright (C) 1998-2003 Free Software Foundation, Inc.           --
--                                                                          --
-- GNAT is free software;  you can  redistribute it  and/or modify it under --
-- terms of the  GNU General Public License as published  by the Free Soft- --
-- ware  Foundation;  either version 2,  or (at your option) any later ver- --
-- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
-- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
-- or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License --
-- for  more details.  You should have  received  a copy of the GNU General --
-- Public License  distributed with GNAT;  see file COPYING.  If not, write --
-- to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, --
-- MA 02111-1307, USA.                                                      --
--                                                                          --
-- GNAT was originally developed  by the GNAT team at  New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc.      --
--                                                                          --
------------------------------------------------------------------------------

with GNAT.OS_Lib;

package Xr_Tabls is

   -------------------
   -- Project files --
   -------------------

   function ALI_File_Name (Ada_File_Name : String) return String;
   --  Returns the ali file name corresponding to Ada_File_Name.

   procedure Create_Project_File (Name : String);
   --  Open and parse a new project file. If the file Name could not be
   --  opened or is not a valid project file, then a project file associated
   --  with the standard default directories is returned

   function Next_Obj_Dir return String;
   --  Returns the next directory to visit to find related ali files
   --  If there are no more such directories, returns a null string.

   function Current_Obj_Dir return String;
   --  Returns the obj_dir which was returned by the last Next_Obj_Dir call

   procedure Reset_Obj_Dir;
   --  Reset the iterator for Obj_Dir

   ------------
   -- Tables --
   ------------

   type Declaration_Reference is private;
   Empty_Declaration : constant Declaration_Reference;

   type Declaration_Array is array (Natural range <>) of Declaration_Reference;
   type Declaration_Array_Access is access Declaration_Array;

   type File_Reference is private;
   Empty_File : constant File_Reference;

   type Reference is private;
   Empty_Reference : constant Reference;

   type Reference_Array is array (Natural range <>) of Reference;
   type Reference_Array_Access is access Reference_Array;

   procedure Free (Arr : in out Reference_Array_Access);

   function Add_Declaration
     (File_Ref     : File_Reference;
      Symbol       : String;
      Line         : Natural;
      Column       : Natural;
      Decl_Type    : Character;
      Remove_Only  : Boolean := False;
      Symbol_Match : Boolean := True)
      return         Declaration_Reference;
   --  Add a new declaration in the table and return the index to it.
   --  Decl_Type is the type of the entity Any previous instance of this
   --  entity in the htable is removed. If Remove_Only is True, then any
   --  previous instance is removed, but the new entity is never inserted.
   --  Symbol_Match should be set to False if the name of the symbol doesn't
   --  match the pattern from the command line. In that case, the entity will
   --  not be output by gnatfind. If Symbol_Match is True, the entity will only
   --  be output if the file name itself matches.

   procedure Add_Parent
     (Declaration : in out Declaration_Reference;
      Symbol      : String;
      Line        : Natural;
      Column      : Natural;
      File_Ref    : File_Reference);
   --  The parent declaration (Symbol in file File_Ref at position Line and
   --  Column) information is added to Declaration.

   function Add_To_Xref_File
     (File_Name       : String;
      Visited         : Boolean := True;
      Emit_Warning    : Boolean := False;
      Gnatchop_File   : String  := "";
      Gnatchop_Offset : Integer := 0)
      return            File_Reference;
   --  Add a new reference to a file in the table. Ref is used to return the
   --  index in the table where this file is stored. Visited is the value which
   --  will be used in the table (if True, the file will not be returned by
   --  Next_Unvisited_File). If Emit_Warning is True and the ali file does
   --  not exist or does not have cross-referencing information, then a
   --  warning will be emitted. Gnatchop_File is the name of the file that
   --  File_Name was extracted from through a call to "gnatchop -r" (using
   --  pragma Source_Reference). Gnatchop_Offset should be the index of the
   --  first line of File_Name within the Gnatchop_File.

   procedure Add_Line
     (File   : File_Reference;
      Line   : Natural;
      Column : Natural);
   --  Add a new reference in a file, which the user has provided on the
   --  command line. This is used for an optimized matching algorithm.

   procedure Add_Reference
     (Declaration   : Declaration_Reference;
      File_Ref      : File_Reference;
      Line          : Natural;
      Column        : Natural;
      Ref_Type      : Character;
      Labels_As_Ref : Boolean);
   --  Add a new reference (Ref_Type = 'r'), body (Ref_Type = 'b') or
   --  modification (Ref_Type = 'm') to an entity. If Labels_As_Ref is True,
   --  then the references to the entity after the end statements ("end Foo")
   --  are counted as actual references. This means that the entity will never
   --  be reported as unreferenced (for instance in the case of gnatxref -u).

   function Get_Declarations
     (Sorted : Boolean := True)
      return   Declaration_Array_Access;
   --  Return a sorted list of all the declarations in the application.
   --  Freeing this array is the responsability of the caller, however it
   --  shouldn't free the actual contents of the array, which are pointers
   --  to internal data

   function References_Count
     (Decl       : Declaration_Reference;
      Get_Reads  : Boolean := False;
      Get_Writes : Boolean := False;
      Get_Bodies : Boolean := False)
      return       Natural;
   --  Return the number of references in Decl for the categories specified
   --  by the Get_* parameters (read-only accesses, write accesses and bodies)

   function Get_References
     (Decl : Declaration_Reference;
      Get_Reads  : Boolean := False;
      Get_Writes : Boolean := False;
      Get_Bodies : Boolean := False)
      return       Reference_Array_Access;
   --  Return a sorted list of all references to the entity in decl.
   --  The parameters Get_* are used to specify what kind of references
   --  should be merged and returned (read-only accesses, write accesses
   --  and bodies).

   function Get_Column (Decl : Declaration_Reference) return String;
   function Get_Column (Ref : Reference) return String;

   function Get_Declaration
     (File_Ref : File_Reference;
      Line     : Natural;
      Column   : Natural)
      return     Declaration_Reference;
   --  Returns reference to the declaration found in file File_Ref at the
   --  given Line and Column

   function Get_Parent
     (Decl : Declaration_Reference)
      return Declaration_Reference;
   --  Returns reference to Decl's parent declaration

   function Get_Emit_Warning (File : File_Reference) return Boolean;
   --  Returns the Emit_Warning field of the structure

   function Get_Gnatchop_File
     (File     : File_Reference;
      With_Dir : Boolean := False)
      return     String;
   function Get_Gnatchop_File
     (Ref      : Reference;
      With_Dir : Boolean := False)
      return     String;
   function Get_Gnatchop_File
     (Decl     : Declaration_Reference;
      With_Dir : Boolean := False)
      return     String;
   --  Return the name of the file that File was extracted from through a
   --  call to "gnatchop -r". The file name for File is returned if File
   --  was not extracted from such a file. The directory will be given only
   --  if With_Dir is True.

   function Get_File
     (Decl     : Declaration_Reference;
      With_Dir : Boolean := False) return String;
   pragma Inline (Get_File);
   --  Extract column number or file name from reference

   function Get_File
     (Ref      : Reference;
      With_Dir : Boolean := False) return String;
   pragma Inline (Get_File);

   function Get_File
     (File     : File_Reference;
      With_Dir : Boolean := False;
      Strip    : Natural := 0) return String;
   --  Returns the file name (and its directory if With_Dir is True or the
   --  user has used the -f switch on the command line. If Strip is not 0,
   --  then the last Strip-th "-..." substrings are removed first. For
   --  instance, with Strip=2, a file name "parent-child1-child2-child3.ali"
   --  would be returned as "parent-child1.ali". This is used when looking
   --  for the ALI file to use for a package, since for separates with have
   --  to use the parent's ALI. The null string is returned if there is no
   --  such parent unit.
   --
   --  Note that this version of Get_File is not inlined

   function Get_File_Ref (Ref : Reference)              return File_Reference;
   function Get_Line     (Decl : Declaration_Reference) return String;
   function Get_Line     (Ref : Reference)              return String;
   function Get_Symbol   (Decl : Declaration_Reference) return String;
   function Get_Type     (Decl : Declaration_Reference) return Character;
   function Is_Parameter (Decl : Declaration_Reference) return Boolean;
   --  Functions that return the contents of a declaration

   function Get_Source_Line (Ref : Reference)              return String;
   function Get_Source_Line (Decl : Declaration_Reference) return String;
   --  Return the source line associated with the reference

   procedure Grep_Source_Files;
   --  Parse all the source files which have at least one reference,
   --  and grep the appropriate source lines so that we'll be able to
   --  display them.  This function should be called once all the .ali
   --  files have been parsed, and only if the appropriate user switch
   --  has been used (gnatfind -s).
   --
   --  Note: To save memory, the strings for the source lines are shared.
   --  Thus it is no longer possible to free the references, or we would
   --  free the same chunk multiple times. It doesn't matter, though, since
   --  this is only called once, prior to exiting gnatfind.

   function Longest_File_Name return Natural;
   --  Returns the longest file name found

   function Match (Decl : Declaration_Reference) return Boolean;
   --  Return True if the declaration matches

   function Match
     (File   : File_Reference;
      Line   : Natural;
      Column : Natural)
      return   Boolean;
   --  Returns True if File:Line:Column was given on the command line
   --  by the user

   function Next_Unvisited_File return File_Reference;
   --  Returns the next unvisited library file in the list
   --  If there is no more unvisited file, return Empty_File.
   --  Two calls to this subprogram will return different files.

   procedure Set_Default_Match (Value : Boolean);
   --  Set the default value for match in declarations.
   --  This is used so that if no file was provided in the
   --  command line, then every file match

   procedure Reset_Directory (File : File_Reference);
   --  Reset the cached directory for file. Next time Get_File is
   --  called, the directory willl be recomputed.

   procedure Set_Unvisited (File_Ref : File_Reference);
   --  Set File_Ref as unvisited. So Next_Unvisited_File will return it.

   procedure Read_File
     (File_Name : String;
      Contents  : out GNAT.OS_Lib.String_Access);
   --  Reads File_Name into the newly allocated strig Contents. A
   --  Types.EOF character will be added to the returned Contents to
   --  simplify parsing. Name_Error is raised if the file was not found.
   --  End_Error is raised if the file could not be read correctly. For
   --  most systems correct reading means that the number of bytes read
   --  is equal to the file size. The exception is OpenVMS where correct
   --  reading means that the number of bytes read is less than or equal
   --  to the file size.

private
   type Project_File (Src_Dir_Length, Obj_Dir_Length : Natural) is record
      Src_Dir : String (1 .. Src_Dir_Length);
      Src_Dir_Index : Integer;

      Obj_Dir            : String (1 .. Obj_Dir_Length);
      Obj_Dir_Index      : Integer;
      Last_Obj_Dir_Start : Natural;
   end record;

   type Project_File_Ptr is access all Project_File;
   --  This is actually a list of all the directories to be searched,
   --  either for source files or for library files

   type Ref_In_File;
   type Ref_In_File_Ptr is access all Ref_In_File;

   type Ref_In_File is record
      Line   : Natural;
      Column : Natural;
      Next   : Ref_In_File_Ptr := null;
   end record;

   type File_Record;
   type File_Reference is access all File_Record;

   Empty_File : constant File_Reference := null;
   type Cst_String_Access is access constant String;

   procedure Free (Str : in out Cst_String_Access);

   type File_Record is record
      File            : Cst_String_Access;
      Dir             : GNAT.OS_Lib.String_Access;
      Lines           : Ref_In_File_Ptr := null;
      Visited         : Boolean         := False;
      Emit_Warning    : Boolean         := False;
      Gnatchop_File   : GNAT.OS_Lib.String_Access   := null;
      Gnatchop_Offset : Integer         := 0;
      Next            : File_Reference  := null;
   end record;
   --  Holds a reference to a source file, that was referenced in at least one
   --  ALI file. Gnatchop_File will contain the name of the file that File was
   --  extracted From. Gnatchop_Offset contains the index of the first line of
   --  File within Gnatchop_File. These two fields are used to properly support
   --  gnatchop files and pragma Source_Reference.
   --
   --  Lines is used for files that were given on the command line, to
   --  memorize the lines and columns that the user specified.

   type Reference_Record;
   type Reference is access all Reference_Record;

   Empty_Reference : constant Reference := null;

   type Reference_Record is record
      File        : File_Reference;
      Line        : Natural;
      Column      : Natural;
      Source_Line : Cst_String_Access;
      Next        : Reference := null;
   end record;
   --  File is a reference to the Ada source file
   --  Source_Line is the Line as it appears in the source file. This
   --  field is only used when the switch is set on the command line of
   --  gnatfind.

   type Declaration_Record;
   type Declaration_Reference is access all Declaration_Record;

   Empty_Declaration : constant Declaration_Reference := null;

   type Declaration_Record (Symbol_Length : Natural) is record
      Key          : Cst_String_Access;
      Symbol       : String (1 .. Symbol_Length);
      Decl         : Reference;
      Is_Parameter : Boolean := False; -- True if entity is subprog param
      Decl_Type    : Character;
      Body_Ref     : Reference := null;
      Ref_Ref      : Reference := null;
      Modif_Ref    : Reference := null;
      Match        : Boolean := False;
      Par_Symbol   : Declaration_Reference := null;
      Next         : Declaration_Reference := null;
   end record;
   --  The lists of referenced (Body_Ref, Ref_Ref and Modif_Ref) are
   --  kept unsorted until the results needs to be printed. This saves
   --  lots of time while the internal tables are created.

   pragma Inline (Get_Column);
   pragma Inline (Get_Emit_Warning);
   pragma Inline (Get_File_Ref);
   pragma Inline (Get_Line);
   pragma Inline (Get_Symbol);
   pragma Inline (Get_Type);
   pragma Inline (Longest_File_Name);
end Xr_Tabls;