|
111
|
1 ------------------------------------------------------------------------------
|
|
|
2 -- --
|
|
|
3 -- GNAT COMPILER COMPONENTS --
|
|
|
4 -- --
|
|
|
5 -- A L I . U T I L --
|
|
|
6 -- --
|
|
|
7 -- B o d y --
|
|
|
8 -- --
|
|
|
9 -- Copyright (C) 1992-2017, 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 Debug; use Debug;
|
|
|
27 with Binderr; use Binderr;
|
|
|
28 with Opt; use Opt;
|
|
|
29 with Output; use Output;
|
|
|
30 with Osint; use Osint;
|
|
|
31 with Scans; use Scans;
|
|
|
32 with Scng;
|
|
|
33 with Sinput.C;
|
|
|
34 with Snames; use Snames;
|
|
|
35 with Stringt;
|
|
|
36 with Styleg;
|
|
|
37
|
|
|
38 with System.OS_Lib; use System.OS_Lib;
|
|
|
39
|
|
|
40 package body ALI.Util is
|
|
|
41
|
|
|
42 -- Empty procedures needed to instantiate Scng. Error procedures are
|
|
|
43 -- empty, because we don't want to report any errors when computing
|
|
|
44 -- a source checksum.
|
|
|
45
|
|
|
46 procedure Post_Scan;
|
|
|
47
|
|
|
48 procedure Error_Msg (Msg : String; Flag_Location : Source_Ptr);
|
|
|
49
|
|
|
50 procedure Error_Msg_S (Msg : String);
|
|
|
51
|
|
|
52 procedure Error_Msg_SC (Msg : String);
|
|
|
53
|
|
|
54 procedure Error_Msg_SP (Msg : String);
|
|
|
55
|
|
|
56 -- Instantiation of Styleg, needed to instantiate Scng
|
|
|
57
|
|
|
58 package Style is new Styleg
|
|
|
59 (Error_Msg, Error_Msg_S, Error_Msg_SC, Error_Msg_SP);
|
|
|
60
|
|
|
61 -- A Scanner is needed to get checksum of a source (procedure
|
|
|
62 -- Get_File_Checksum).
|
|
|
63
|
|
|
64 package Scanner is new Scng
|
|
|
65 (Post_Scan, Error_Msg, Error_Msg_S, Error_Msg_SC, Error_Msg_SP, Style);
|
|
|
66
|
|
|
67 type Header_Num is range 0 .. 1_000;
|
|
|
68
|
|
|
69 function Hash (F : File_Name_Type) return Header_Num;
|
|
|
70 -- Function used to compute hash of ALI file name
|
|
|
71
|
|
|
72 package Interfaces is new Simple_HTable (
|
|
|
73 Header_Num => Header_Num,
|
|
|
74 Element => Boolean,
|
|
|
75 No_Element => False,
|
|
|
76 Key => File_Name_Type,
|
|
|
77 Hash => Hash,
|
|
|
78 Equal => "=");
|
|
|
79
|
|
|
80 ---------------------
|
|
|
81 -- Checksums_Match --
|
|
|
82 ---------------------
|
|
|
83
|
|
|
84 function Checksums_Match (Checksum1, Checksum2 : Word) return Boolean is
|
|
|
85 begin
|
|
|
86 return Checksum1 = Checksum2 and then Checksum1 /= Checksum_Error;
|
|
|
87 end Checksums_Match;
|
|
|
88
|
|
|
89 ---------------
|
|
|
90 -- Error_Msg --
|
|
|
91 ---------------
|
|
|
92
|
|
|
93 procedure Error_Msg (Msg : String; Flag_Location : Source_Ptr) is
|
|
|
94 pragma Warnings (Off, Msg);
|
|
|
95 pragma Warnings (Off, Flag_Location);
|
|
|
96 begin
|
|
|
97 null;
|
|
|
98 end Error_Msg;
|
|
|
99
|
|
|
100 -----------------
|
|
|
101 -- Error_Msg_S --
|
|
|
102 -----------------
|
|
|
103
|
|
|
104 procedure Error_Msg_S (Msg : String) is
|
|
|
105 pragma Warnings (Off, Msg);
|
|
|
106 begin
|
|
|
107 null;
|
|
|
108 end Error_Msg_S;
|
|
|
109
|
|
|
110 ------------------
|
|
|
111 -- Error_Msg_SC --
|
|
|
112 ------------------
|
|
|
113
|
|
|
114 procedure Error_Msg_SC (Msg : String) is
|
|
|
115 pragma Warnings (Off, Msg);
|
|
|
116 begin
|
|
|
117 null;
|
|
|
118 end Error_Msg_SC;
|
|
|
119
|
|
|
120 ------------------
|
|
|
121 -- Error_Msg_SP --
|
|
|
122 ------------------
|
|
|
123
|
|
|
124 procedure Error_Msg_SP (Msg : String) is
|
|
|
125 pragma Warnings (Off, Msg);
|
|
|
126 begin
|
|
|
127 null;
|
|
|
128 end Error_Msg_SP;
|
|
|
129
|
|
|
130 -----------------------
|
|
|
131 -- Get_File_Checksum --
|
|
|
132 -----------------------
|
|
|
133
|
|
|
134 function Get_File_Checksum (Fname : File_Name_Type) return Word is
|
|
|
135 Full_Name : File_Name_Type;
|
|
|
136 Source_Index : Source_File_Index;
|
|
|
137
|
|
|
138 begin
|
|
|
139 Full_Name := Find_File (Fname, Osint.Source);
|
|
|
140
|
|
|
141 -- If we cannot find the file, then return an impossible checksum,
|
|
|
142 -- impossible because checksums have the high order bit zero, so
|
|
|
143 -- that checksums do not match.
|
|
|
144
|
|
|
145 if Full_Name = No_File then
|
|
|
146 return Checksum_Error;
|
|
|
147 end if;
|
|
|
148
|
|
|
149 Source_Index := Sinput.C.Load_File (Get_Name_String (Full_Name));
|
|
|
150
|
|
|
151 if Source_Index <= No_Source_File then
|
|
|
152 return Checksum_Error;
|
|
|
153 end if;
|
|
|
154
|
|
|
155 Scanner.Initialize_Scanner (Source_Index);
|
|
|
156
|
|
|
157 -- Make sure that the project language reserved words are not
|
|
|
158 -- recognized as reserved words, but as identifiers. The byte info for
|
|
|
159 -- those names have been set if we are in gnatmake.
|
|
|
160
|
|
|
161 Set_Name_Table_Byte (Name_Project, 0);
|
|
|
162 Set_Name_Table_Byte (Name_Extends, 0);
|
|
|
163 Set_Name_Table_Byte (Name_External, 0);
|
|
|
164 Set_Name_Table_Byte (Name_External_As_List, 0);
|
|
|
165
|
|
|
166 -- Scan the complete file to compute its checksum
|
|
|
167
|
|
|
168 loop
|
|
|
169 Scanner.Scan;
|
|
|
170 exit when Token = Tok_EOF;
|
|
|
171 end loop;
|
|
|
172
|
|
|
173 return Scans.Checksum;
|
|
|
174 end Get_File_Checksum;
|
|
|
175
|
|
|
176 ----------
|
|
|
177 -- Hash --
|
|
|
178 ----------
|
|
|
179
|
|
|
180 function Hash (F : File_Name_Type) return Header_Num is
|
|
|
181 begin
|
|
|
182 return Header_Num (Int (F) rem Header_Num'Range_Length);
|
|
|
183 end Hash;
|
|
|
184
|
|
|
185 ---------------------------
|
|
|
186 -- Initialize_ALI_Source --
|
|
|
187 ---------------------------
|
|
|
188
|
|
|
189 procedure Initialize_ALI_Source is
|
|
|
190 begin
|
|
|
191 -- When (re)initializing ALI data structures the ALI user expects to
|
|
|
192 -- get a fresh set of data structures. Thus we first need to erase the
|
|
|
193 -- marks put in the name table by the previous set of ALI routine calls.
|
|
|
194 -- This loop is empty and harmless the first time in.
|
|
|
195
|
|
|
196 for J in Source.First .. Source.Last loop
|
|
|
197 Set_Name_Table_Int (Source.Table (J).Sfile, 0);
|
|
|
198 Source.Table (J).Source_Found := False;
|
|
|
199 end loop;
|
|
|
200
|
|
|
201 Source.Init;
|
|
|
202 Interfaces.Reset;
|
|
|
203 end Initialize_ALI_Source;
|
|
|
204
|
|
|
205 ---------------
|
|
|
206 -- Post_Scan --
|
|
|
207 ---------------
|
|
|
208
|
|
|
209 procedure Post_Scan is
|
|
|
210 begin
|
|
|
211 null;
|
|
|
212 end Post_Scan;
|
|
|
213
|
|
|
214 ----------------------
|
|
|
215 -- Read_Withed_ALIs --
|
|
|
216 ----------------------
|
|
|
217
|
|
|
218 procedure Read_Withed_ALIs
|
|
|
219 (Id : ALI_Id;
|
|
|
220 Ignore_Errors : Boolean := False)
|
|
|
221 is
|
|
|
222 Afile : File_Name_Type;
|
|
|
223 Text : Text_Buffer_Ptr;
|
|
|
224 Idread : ALI_Id;
|
|
|
225
|
|
|
226 begin
|
|
|
227 -- Process all dependent units
|
|
|
228
|
|
|
229 for U in ALIs.Table (Id).First_Unit .. ALIs.Table (Id).Last_Unit loop
|
|
|
230 for
|
|
|
231 W in Units.Table (U).First_With .. Units.Table (U).Last_With
|
|
|
232 loop
|
|
|
233 Afile := Withs.Table (W).Afile;
|
|
|
234
|
|
|
235 -- Only process if not a generic (Afile /= No_File) and if
|
|
|
236 -- file has not been processed already.
|
|
|
237
|
|
|
238 if Afile /= No_File
|
|
|
239 and then Get_Name_Table_Int (Afile) = 0
|
|
|
240 then
|
|
|
241 Text := Read_Library_Info (Afile);
|
|
|
242
|
|
|
243 -- Unless Ignore_Errors is true, return with an error if source
|
|
|
244 -- cannot be found. We used to skip this check when we did not
|
|
|
245 -- compile library generics separately, but we now always do,
|
|
|
246 -- so there is no special case here anymore.
|
|
|
247
|
|
|
248 if Text = null then
|
|
|
249
|
|
|
250 if not Ignore_Errors then
|
|
|
251 Error_Msg_File_1 := Afile;
|
|
|
252 Error_Msg_File_2 := Withs.Table (W).Sfile;
|
|
|
253 Error_Msg ("{ not found, { must be compiled");
|
|
|
254 Set_Name_Table_Int (Afile, Int (No_Unit_Id));
|
|
|
255 return;
|
|
|
256 end if;
|
|
|
257
|
|
|
258 else
|
|
|
259 -- Enter in ALIs table
|
|
|
260
|
|
|
261 Idread :=
|
|
|
262 Scan_ALI
|
|
|
263 (F => Afile,
|
|
|
264 T => Text,
|
|
|
265 Ignore_ED => False,
|
|
|
266 Err => False);
|
|
|
267
|
|
|
268 Free (Text);
|
|
|
269
|
|
|
270 if ALIs.Table (Idread).Compile_Errors
|
|
|
271 and then not Ignore_Errors
|
|
|
272 then
|
|
|
273 Error_Msg_File_1 := Withs.Table (W).Sfile;
|
|
|
274 Error_Msg ("{ had errors, must be fixed, and recompiled");
|
|
|
275 Set_Name_Table_Int (Afile, Int (No_Unit_Id));
|
|
|
276
|
|
|
277 -- In GNATprove mode, object files are never generated, so
|
|
|
278 -- No_Object=True is not considered an error.
|
|
|
279
|
|
|
280 elsif ALIs.Table (Idread).No_Object
|
|
|
281 and then not GNATprove_Mode
|
|
|
282 and then not Ignore_Errors
|
|
|
283 then
|
|
|
284 Error_Msg_File_1 := Withs.Table (W).Sfile;
|
|
|
285 Error_Msg ("{ must be recompiled");
|
|
|
286 Set_Name_Table_Int (Afile, Int (No_Unit_Id));
|
|
|
287 end if;
|
|
|
288
|
|
|
289 -- If the Unit is an Interface to a Stand-Alone Library,
|
|
|
290 -- set the Interface flag in the Withs table, so that its
|
|
|
291 -- dependant are not considered for elaboration order.
|
|
|
292
|
|
|
293 if ALIs.Table (Idread).SAL_Interface then
|
|
|
294 Withs.Table (W).SAL_Interface := True;
|
|
|
295 Interface_Library_Unit := True;
|
|
|
296
|
|
|
297 -- Set the entry in the Interfaces hash table, so that
|
|
|
298 -- other units that import this unit will set the flag
|
|
|
299 -- in their entry in the Withs table.
|
|
|
300
|
|
|
301 Interfaces.Set (Afile, True);
|
|
|
302
|
|
|
303 else
|
|
|
304 -- Otherwise, recurse to get new dependents
|
|
|
305
|
|
|
306 Read_Withed_ALIs (Idread);
|
|
|
307 end if;
|
|
|
308 end if;
|
|
|
309
|
|
|
310 -- If the ALI file has already been processed and is an interface,
|
|
|
311 -- set the flag in the entry of the Withs table.
|
|
|
312
|
|
|
313 elsif Interface_Library_Unit and then Interfaces.Get (Afile) then
|
|
|
314 Withs.Table (W).SAL_Interface := True;
|
|
|
315 end if;
|
|
|
316 end loop;
|
|
|
317 end loop;
|
|
|
318 end Read_Withed_ALIs;
|
|
|
319
|
|
|
320 ----------------------
|
|
|
321 -- Set_Source_Table --
|
|
|
322 ----------------------
|
|
|
323
|
|
|
324 procedure Set_Source_Table (A : ALI_Id) is
|
|
|
325 F : File_Name_Type;
|
|
|
326 S : Source_Id;
|
|
|
327 Stamp : Time_Stamp_Type;
|
|
|
328
|
|
|
329 begin
|
|
|
330 Sdep_Loop : for D in
|
|
|
331 ALIs.Table (A).First_Sdep .. ALIs.Table (A).Last_Sdep
|
|
|
332 loop
|
|
|
333 F := Sdep.Table (D).Sfile;
|
|
|
334
|
|
|
335 if F /= No_File then
|
|
|
336
|
|
|
337 -- If this is the first time we are seeing this source file,
|
|
|
338 -- then make a new entry in the source table.
|
|
|
339
|
|
|
340 if Get_Name_Table_Int (F) = 0 then
|
|
|
341 Source.Increment_Last;
|
|
|
342 S := Source.Last;
|
|
|
343 Set_Name_Table_Int (F, Int (S));
|
|
|
344 Source.Table (S).Sfile := F;
|
|
|
345 Source.Table (S).All_Timestamps_Match := True;
|
|
|
346
|
|
|
347 -- Initialize checksum fields
|
|
|
348
|
|
|
349 Source.Table (S).Checksum := Sdep.Table (D).Checksum;
|
|
|
350 Source.Table (S).All_Checksums_Match := True;
|
|
|
351
|
|
|
352 -- In check source files mode, try to get time stamp from file
|
|
|
353
|
|
|
354 if Opt.Check_Source_Files then
|
|
|
355 Stamp := Source_File_Stamp (F);
|
|
|
356
|
|
|
357 -- If we got the stamp, then set the stamp in the source
|
|
|
358 -- table entry and mark it as set from the source so that
|
|
|
359 -- it does not get subsequently changed.
|
|
|
360
|
|
|
361 if Stamp (Stamp'First) /= ' ' then
|
|
|
362 Source.Table (S).Stamp := Stamp;
|
|
|
363 Source.Table (S).Source_Found := True;
|
|
|
364 Source.Table (S).Stamp_File := F;
|
|
|
365
|
|
|
366 -- If we could not find the file, then the stamp is set
|
|
|
367 -- from the dependency table entry (to be possibly reset
|
|
|
368 -- if we find a later stamp in subsequent processing)
|
|
|
369
|
|
|
370 else
|
|
|
371 Source.Table (S).Stamp := Sdep.Table (D).Stamp;
|
|
|
372 Source.Table (S).Source_Found := False;
|
|
|
373 Source.Table (S).Stamp_File := ALIs.Table (A).Afile;
|
|
|
374
|
|
|
375 -- In All_Sources mode, flag error of file not found
|
|
|
376
|
|
|
377 if Opt.All_Sources then
|
|
|
378 Error_Msg_File_1 := F;
|
|
|
379 Error_Msg ("cannot locate {");
|
|
|
380 end if;
|
|
|
381 end if;
|
|
|
382
|
|
|
383 -- First time for this source file, but Check_Source_Files
|
|
|
384 -- is off, so simply initialize the stamp from the Sdep entry
|
|
|
385
|
|
|
386 else
|
|
|
387 Source.Table (S).Stamp := Sdep.Table (D).Stamp;
|
|
|
388 Source.Table (S).Source_Found := False;
|
|
|
389 Source.Table (S).Stamp_File := ALIs.Table (A).Afile;
|
|
|
390 end if;
|
|
|
391
|
|
|
392 -- Here if this is not the first time for this source file,
|
|
|
393 -- so that the source table entry is already constructed.
|
|
|
394
|
|
|
395 else
|
|
|
396 S := Source_Id (Get_Name_Table_Int (F));
|
|
|
397
|
|
|
398 -- Update checksum flag
|
|
|
399
|
|
|
400 if not Checksums_Match
|
|
|
401 (Sdep.Table (D).Checksum, Source.Table (S).Checksum)
|
|
|
402 then
|
|
|
403 Source.Table (S).All_Checksums_Match := False;
|
|
|
404 end if;
|
|
|
405
|
|
|
406 -- Check for time stamp mismatch
|
|
|
407
|
|
|
408 if Sdep.Table (D).Stamp /= Source.Table (S).Stamp then
|
|
|
409 Source.Table (S).All_Timestamps_Match := False;
|
|
|
410
|
|
|
411 -- When we have a time stamp mismatch, we go look for the
|
|
|
412 -- source file even if Check_Source_Files is false, since
|
|
|
413 -- if we find it, then we can use it to resolve which of the
|
|
|
414 -- two timestamps in the ALI files is likely to be correct.
|
|
|
415 -- We only look in the current directory, because when
|
|
|
416 -- Check_Source_Files is false, other search directories are
|
|
|
417 -- likely to be incorrect.
|
|
|
418
|
|
|
419 if not Check_Source_Files
|
|
|
420 and then Is_Regular_File (Get_Name_String (F))
|
|
|
421 then
|
|
|
422 Stamp := Source_File_Stamp (F);
|
|
|
423
|
|
|
424 if Stamp (Stamp'First) /= ' ' then
|
|
|
425 Source.Table (S).Stamp := Stamp;
|
|
|
426 Source.Table (S).Source_Found := True;
|
|
|
427 Source.Table (S).Stamp_File := F;
|
|
|
428 end if;
|
|
|
429 end if;
|
|
|
430
|
|
|
431 -- If the stamp in the source table entry was set from the
|
|
|
432 -- source file, then we do not change it (the stamp in the
|
|
|
433 -- source file is always taken as the "right" one).
|
|
|
434
|
|
|
435 if Source.Table (S).Source_Found then
|
|
|
436 null;
|
|
|
437
|
|
|
438 -- Otherwise, we have no source file available, so we guess
|
|
|
439 -- that the later of the two timestamps is the right one.
|
|
|
440 -- Note that this guess only affects which error messages
|
|
|
441 -- are issued later on, not correct functionality.
|
|
|
442
|
|
|
443 else
|
|
|
444 if Sdep.Table (D).Stamp > Source.Table (S).Stamp then
|
|
|
445 Source.Table (S).Stamp := Sdep.Table (D).Stamp;
|
|
|
446 Source.Table (S).Stamp_File := ALIs.Table (A).Afile;
|
|
|
447 end if;
|
|
|
448 end if;
|
|
|
449 end if;
|
|
|
450 end if;
|
|
|
451
|
|
|
452 -- Set the checksum value in the source table
|
|
|
453
|
|
|
454 S := Source_Id (Get_Name_Table_Int (F));
|
|
|
455 Source.Table (S).Checksum := Sdep.Table (D).Checksum;
|
|
|
456 end if;
|
|
|
457
|
|
|
458 end loop Sdep_Loop;
|
|
|
459 end Set_Source_Table;
|
|
|
460
|
|
|
461 ----------------------
|
|
|
462 -- Set_Source_Table --
|
|
|
463 ----------------------
|
|
|
464
|
|
|
465 procedure Set_Source_Table is
|
|
|
466 begin
|
|
|
467 for A in ALIs.First .. ALIs.Last loop
|
|
|
468 Set_Source_Table (A);
|
|
|
469 end loop;
|
|
|
470 end Set_Source_Table;
|
|
|
471
|
|
|
472 -------------------------
|
|
|
473 -- Time_Stamp_Mismatch --
|
|
|
474 -------------------------
|
|
|
475
|
|
|
476 function Time_Stamp_Mismatch
|
|
|
477 (A : ALI_Id;
|
|
|
478 Read_Only : Boolean := False) return File_Name_Type
|
|
|
479 is
|
|
|
480 Src : Source_Id;
|
|
|
481 -- Source file Id for the current Sdep entry
|
|
|
482
|
|
|
483 begin
|
|
|
484 for D in ALIs.Table (A).First_Sdep .. ALIs.Table (A).Last_Sdep loop
|
|
|
485 Src := Source_Id (Get_Name_Table_Int (Sdep.Table (D).Sfile));
|
|
|
486
|
|
|
487 if Opt.Minimal_Recompilation
|
|
|
488 and then Sdep.Table (D).Stamp /= Source.Table (Src).Stamp
|
|
|
489 then
|
|
|
490 -- If minimal recompilation is in action, replace the stamp
|
|
|
491 -- of the source file in the table if checksums match.
|
|
|
492
|
|
|
493 -- ??? It is probably worth updating the ALI file with a new
|
|
|
494 -- field to avoid recomputing it each time. In any case we ensure
|
|
|
495 -- that we don't gobble up string table space by doing a mark
|
|
|
496 -- release around this computation.
|
|
|
497
|
|
|
498 Stringt.Mark;
|
|
|
499
|
|
|
500 if Checksums_Match
|
|
|
501 (Get_File_Checksum (Sdep.Table (D).Sfile),
|
|
|
502 Source.Table (Src).Checksum)
|
|
|
503 then
|
|
|
504 if Verbose_Mode then
|
|
|
505 Write_Str (" ");
|
|
|
506 Write_Str (Get_Name_String (Sdep.Table (D).Sfile));
|
|
|
507 Write_Str (": up to date, different timestamps " &
|
|
|
508 "but same checksum");
|
|
|
509 Write_Eol;
|
|
|
510 end if;
|
|
|
511
|
|
|
512 Sdep.Table (D).Stamp := Source.Table (Src).Stamp;
|
|
|
513 end if;
|
|
|
514
|
|
|
515 Stringt.Release;
|
|
|
516 end if;
|
|
|
517
|
|
|
518 if (not Read_Only) or else Source.Table (Src).Source_Found then
|
|
|
519 if not Source.Table (Src).Source_Found
|
|
|
520 or else Sdep.Table (D).Stamp /= Source.Table (Src).Stamp
|
|
|
521 then
|
|
|
522 -- If -dt debug flag set, output time stamp found/expected
|
|
|
523
|
|
|
524 if Source.Table (Src).Source_Found and then Debug_Flag_T then
|
|
|
525 Write_Str ("Source: """);
|
|
|
526 Get_Name_String (Sdep.Table (D).Sfile);
|
|
|
527 Write_Str (Name_Buffer (1 .. Name_Len));
|
|
|
528 Write_Line ("""");
|
|
|
529
|
|
|
530 Write_Str (" time stamp expected: ");
|
|
|
531 Write_Line (String (Sdep.Table (D).Stamp));
|
|
|
532
|
|
|
533 Write_Str (" time stamp found: ");
|
|
|
534 Write_Line (String (Source.Table (Src).Stamp));
|
|
|
535 end if;
|
|
|
536
|
|
|
537 -- Return the source file
|
|
|
538
|
|
|
539 return Source.Table (Src).Sfile;
|
|
|
540 end if;
|
|
|
541 end if;
|
|
|
542 end loop;
|
|
|
543
|
|
|
544 return No_File;
|
|
|
545 end Time_Stamp_Mismatch;
|
|
|
546
|
|
|
547 end ALI.Util;
|
