| ------------------------------------------------------------------------------ | |
| -- -- | |
| -- GNAT COMPILER COMPONENTS -- | |
| -- -- | |
| -- B I N D O . V A L I D A T O R S -- | |
| -- -- | |
| -- B o d y -- | |
| -- -- | |
| -- Copyright (C) 2019-2026, 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 3, 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 COPYING3. If not, go to -- | |
| -- http://www.gnu.org/licenses for a complete copy of the license. -- | |
| -- -- | |
| -- GNAT was originally developed by the GNAT team at New York University. -- | |
| -- Extensive contributions were provided by Ada Core Technologies Inc. -- | |
| -- -- | |
| ------------------------------------------------------------------------------ | |
| with Debug; use Debug; | |
| with Output; use Output; | |
| with Types; use Types; | |
| with Bindo.Units; | |
| use Bindo.Units; | |
| with Bindo.Writers; | |
| use Bindo.Writers; | |
| use Bindo.Writers.Phase_Writers; | |
| package body Bindo.Validators is | |
| ----------------------- | |
| -- Local subprograms -- | |
| ----------------------- | |
| procedure Write_Error | |
| (Msg : String; | |
| Flag : out Boolean); | |
| pragma Inline (Write_Error); | |
| -- Write error message Msg to standard output and set flag Flag to True | |
| ---------------------- | |
| -- Cycle_Validators -- | |
| ---------------------- | |
| package body Cycle_Validators is | |
| Has_Invalid_Cycle : Boolean := False; | |
| -- Flag set when the library graph contains an invalid cycle | |
| ----------------------- | |
| -- Local subprograms -- | |
| ----------------------- | |
| procedure Validate_Cycle | |
| (G : Library_Graph; | |
| Cycle : Library_Graph_Cycle_Id); | |
| pragma Inline (Validate_Cycle); | |
| -- Ensure that a cycle meets the following requirements: | |
| -- | |
| -- * Is of proper kind | |
| -- * Has enough edges to form a circuit | |
| -- * No edge is repeated | |
| procedure Validate_Cycle_Path | |
| (G : Library_Graph; | |
| Cycle : Library_Graph_Cycle_Id); | |
| pragma Inline (Validate_Cycle_Path); | |
| -- Ensure that the path of a cycle meets the following requirements: | |
| -- | |
| -- * No edge is repeated | |
| -------------------- | |
| -- Validate_Cycle -- | |
| -------------------- | |
| procedure Validate_Cycle | |
| (G : Library_Graph; | |
| Cycle : Library_Graph_Cycle_Id) | |
| is | |
| Msg : constant String := "Validate_Cycle"; | |
| begin | |
| pragma Assert (Present (G)); | |
| if not Present (Cycle) then | |
| Write_Error (Msg, Has_Invalid_Cycle); | |
| Write_Str (" empty cycle"); | |
| Write_Eol; | |
| Write_Eol; | |
| return; | |
| end if; | |
| if Kind (G, Cycle) = No_Cycle_Kind then | |
| Write_Error (Msg, Has_Invalid_Cycle); | |
| Write_Str (" cycle (LGC_Id_"); | |
| Write_Int (Int (Cycle)); | |
| Write_Str (") is a No_Cycle"); | |
| Write_Eol; | |
| Write_Eol; | |
| end if; | |
| -- A cycle requires at least one edge (self cycle) to form a circuit | |
| if Length (G, Cycle) < 1 then | |
| Write_Error (Msg, Has_Invalid_Cycle); | |
| Write_Str (" cycle (LGC_Id_"); | |
| Write_Int (Int (Cycle)); | |
| Write_Str (") does not contain enough edges"); | |
| Write_Eol; | |
| Write_Eol; | |
| end if; | |
| Validate_Cycle_Path (G, Cycle); | |
| end Validate_Cycle; | |
| ------------------------- | |
| -- Validate_Cycle_Path -- | |
| ------------------------- | |
| procedure Validate_Cycle_Path | |
| (G : Library_Graph; | |
| Cycle : Library_Graph_Cycle_Id) | |
| is | |
| Msg : constant String := "Validate_Cycle_Path"; | |
| Edge : Library_Graph_Edge_Id; | |
| Edges : LGE_Sets.Membership_Set; | |
| Iter : Edges_Of_Cycle_Iterator; | |
| begin | |
| pragma Assert (Present (G)); | |
| pragma Assert (Present (Cycle)); | |
| -- Use a set to detect duplicate edges while traversing the cycle | |
| Edges := LGE_Sets.Create (Length (G, Cycle)); | |
| -- Inspect the edges of the cycle, trying to catch duplicates | |
| Iter := Iterate_Edges_Of_Cycle (G, Cycle); | |
| while Has_Next (Iter) loop | |
| Next (Iter, Edge); | |
| -- The current edge has already been encountered while traversing | |
| -- the cycle. This indicates that the cycle is malformed as edges | |
| -- are not repeated in the circuit. | |
| if LGE_Sets.Contains (Edges, Edge) then | |
| Write_Error (Msg, Has_Invalid_Cycle); | |
| Write_Str (" library graph edge (LGE_Id_"); | |
| Write_Int (Int (Edge)); | |
| Write_Str (") is repeated in cycle (LGC_Id_"); | |
| Write_Int (Int (Cycle)); | |
| Write_Str (")"); | |
| Write_Eol; | |
| -- Otherwise add the current edge to the set of encountered edges | |
| else | |
| LGE_Sets.Insert (Edges, Edge); | |
| end if; | |
| end loop; | |
| LGE_Sets.Destroy (Edges); | |
| end Validate_Cycle_Path; | |
| --------------------- | |
| -- Validate_Cycles -- | |
| --------------------- | |
| procedure Validate_Cycles (G : Library_Graph) is | |
| Cycle : Library_Graph_Cycle_Id; | |
| Iter : All_Cycle_Iterator; | |
| begin | |
| pragma Assert (Present (G)); | |
| -- Nothing to do when switch -d_V (validate bindo cycles, graphs, and | |
| -- order) is not in effect. | |
| if not Debug_Flag_Underscore_VV then | |
| return; | |
| end if; | |
| Start_Phase (Cycle_Validation); | |
| Iter := Iterate_All_Cycles (G); | |
| while Has_Next (Iter) loop | |
| Next (Iter, Cycle); | |
| Validate_Cycle (G, Cycle); | |
| end loop; | |
| End_Phase (Cycle_Validation); | |
| if Has_Invalid_Cycle then | |
| raise Invalid_Cycle; | |
| end if; | |
| end Validate_Cycles; | |
| end Cycle_Validators; | |
| ---------------------------------- | |
| -- Elaboration_Order_Validators -- | |
| ---------------------------------- | |
| package body Elaboration_Order_Validators is | |
| Has_Invalid_Data : Boolean := False; | |
| -- Flag set when the elaboration order contains invalid data | |
| ----------------------- | |
| -- Local subprograms -- | |
| ----------------------- | |
| function Build_Elaborable_Unit_Set return Unit_Sets.Membership_Set; | |
| pragma Inline (Build_Elaborable_Unit_Set); | |
| -- Create a set from all units that need to be elaborated | |
| procedure Report_Missing_Elaboration (U_Id : Unit_Id); | |
| pragma Inline (Report_Missing_Elaboration); | |
| -- Emit an error concerning unit U_Id that must be elaborated, but was | |
| -- not. | |
| procedure Report_Missing_Elaborations (Set : Unit_Sets.Membership_Set); | |
| pragma Inline (Report_Missing_Elaborations); | |
| -- Emit errors on all units in set Set that must be elaborated, but were | |
| -- not. | |
| procedure Report_Spurious_Elaboration (U_Id : Unit_Id); | |
| pragma Inline (Report_Spurious_Elaboration); | |
| -- Emit an error concerning unit U_Id that is incorrectly elaborated | |
| procedure Validate_Unit | |
| (U_Id : Unit_Id; | |
| Elab_Set : Unit_Sets.Membership_Set); | |
| pragma Inline (Validate_Unit); | |
| -- Validate the elaboration status of unit U_Id. Elab_Set is the set of | |
| -- all units that need to be elaborated. | |
| procedure Validate_Units (Order : Unit_Id_Table); | |
| pragma Inline (Validate_Units); | |
| -- Validate all units in elaboration order Order | |
| ------------------------------- | |
| -- Build_Elaborable_Unit_Set -- | |
| ------------------------------- | |
| function Build_Elaborable_Unit_Set return Unit_Sets.Membership_Set is | |
| Iter : Elaborable_Units_Iterator; | |
| Set : Unit_Sets.Membership_Set; | |
| U_Id : Unit_Id; | |
| begin | |
| Set := Unit_Sets.Create (Number_Of_Elaborable_Units); | |
| Iter := Iterate_Elaborable_Units; | |
| while Has_Next (Iter) loop | |
| Next (Iter, U_Id); | |
| Unit_Sets.Insert (Set, U_Id); | |
| end loop; | |
| return Set; | |
| end Build_Elaborable_Unit_Set; | |
| -------------------------------- | |
| -- Report_Missing_Elaboration -- | |
| -------------------------------- | |
| procedure Report_Missing_Elaboration (U_Id : Unit_Id) is | |
| Msg : constant String := "Report_Missing_Elaboration"; | |
| begin | |
| pragma Assert (Present (U_Id)); | |
| Write_Error (Msg, Has_Invalid_Data); | |
| Write_Str ("unit (U_Id_"); | |
| Write_Int (Int (U_Id)); | |
| Write_Str (") name = "); | |
| Write_Name (Name (U_Id)); | |
| Write_Str (" must be elaborated"); | |
| Write_Eol; | |
| end Report_Missing_Elaboration; | |
| --------------------------------- | |
| -- Report_Missing_Elaborations -- | |
| --------------------------------- | |
| procedure Report_Missing_Elaborations (Set : Unit_Sets.Membership_Set) is | |
| Iter : Unit_Sets.Iterator; | |
| U_Id : Unit_Id; | |
| begin | |
| Iter := Unit_Sets.Iterate (Set); | |
| while Unit_Sets.Has_Next (Iter) loop | |
| Unit_Sets.Next (Iter, U_Id); | |
| Report_Missing_Elaboration (U_Id); | |
| end loop; | |
| end Report_Missing_Elaborations; | |
| --------------------------------- | |
| -- Report_Spurious_Elaboration -- | |
| --------------------------------- | |
| procedure Report_Spurious_Elaboration (U_Id : Unit_Id) is | |
| Msg : constant String := "Report_Spurious_Elaboration"; | |
| begin | |
| pragma Assert (Present (U_Id)); | |
| Write_Error (Msg, Has_Invalid_Data); | |
| Write_Str ("unit (U_Id_"); | |
| Write_Int (Int (U_Id)); | |
| Write_Str (") name = "); | |
| Write_Name (Name (U_Id)); | |
| Write_Str (" must not be elaborated"); | |
| end Report_Spurious_Elaboration; | |
| -------------------------------- | |
| -- Validate_Elaboration_Order -- | |
| -------------------------------- | |
| procedure Validate_Elaboration_Order (Order : Unit_Id_Table) is | |
| begin | |
| -- Nothing to do when switch -d_V (validate bindo cycles, graphs, and | |
| -- order) is not in effect. | |
| if not Debug_Flag_Underscore_VV then | |
| return; | |
| end if; | |
| Start_Phase (Elaboration_Order_Validation); | |
| Validate_Units (Order); | |
| End_Phase (Elaboration_Order_Validation); | |
| if Has_Invalid_Data then | |
| raise Invalid_Elaboration_Order; | |
| end if; | |
| end Validate_Elaboration_Order; | |
| ------------------- | |
| -- Validate_Unit -- | |
| ------------------- | |
| procedure Validate_Unit | |
| (U_Id : Unit_Id; | |
| Elab_Set : Unit_Sets.Membership_Set) | |
| is | |
| begin | |
| pragma Assert (Present (U_Id)); | |
| -- The current unit in the elaboration order appears within the set | |
| -- of units that require elaboration. Remove it from the set. | |
| if Unit_Sets.Contains (Elab_Set, U_Id) then | |
| Unit_Sets.Delete (Elab_Set, U_Id); | |
| -- Otherwise the current unit in the elaboration order must not be | |
| -- elaborated. | |
| else | |
| Report_Spurious_Elaboration (U_Id); | |
| end if; | |
| end Validate_Unit; | |
| -------------------- | |
| -- Validate_Units -- | |
| -------------------- | |
| procedure Validate_Units (Order : Unit_Id_Table) is | |
| Elab_Set : Unit_Sets.Membership_Set; | |
| begin | |
| -- Collect all units in the compilation that need to be elaborated | |
| -- in a set. | |
| Elab_Set := Build_Elaborable_Unit_Set; | |
| -- Validate each unit in the elaboration order against the set of | |
| -- units that need to be elaborated. | |
| for Index in Unit_Id_Tables.First .. Unit_Id_Tables.Last (Order) loop | |
| Validate_Unit | |
| (U_Id => Order.Table (Index), | |
| Elab_Set => Elab_Set); | |
| end loop; | |
| -- At this point all units that need to be elaborated should have | |
| -- been eliminated from the set. Report any units that are missing | |
| -- their elaboration. | |
| Report_Missing_Elaborations (Elab_Set); | |
| Unit_Sets.Destroy (Elab_Set); | |
| end Validate_Units; | |
| end Elaboration_Order_Validators; | |
| --------------------------------- | |
| -- Invocation_Graph_Validators -- | |
| --------------------------------- | |
| package body Invocation_Graph_Validators is | |
| Has_Invalid_Data : Boolean := False; | |
| -- Flag set when the invocation graph contains invalid data | |
| ----------------------- | |
| -- Local subprograms -- | |
| ----------------------- | |
| procedure Validate_Invocation_Graph_Edge | |
| (G : Invocation_Graph; | |
| Edge : Invocation_Graph_Edge_Id); | |
| pragma Inline (Validate_Invocation_Graph_Edge); | |
| -- Verify that the attributes of edge Edge of invocation graph G are | |
| -- properly set. | |
| procedure Validate_Invocation_Graph_Edges (G : Invocation_Graph); | |
| pragma Inline (Validate_Invocation_Graph_Edges); | |
| -- Verify that the attributes of all edges of invocation graph G are | |
| -- properly set. | |
| procedure Validate_Invocation_Graph_Vertex | |
| (G : Invocation_Graph; | |
| Vertex : Invocation_Graph_Vertex_Id); | |
| pragma Inline (Validate_Invocation_Graph_Vertex); | |
| -- Verify that the attributes of vertex Vertex of invocation graph G are | |
| -- properly set. | |
| procedure Validate_Invocation_Graph_Vertices (G : Invocation_Graph); | |
| pragma Inline (Validate_Invocation_Graph_Vertices); | |
| -- Verify that the attributes of all vertices of invocation graph G are | |
| -- properly set. | |
| ------------------------------- | |
| -- Validate_Invocation_Graph -- | |
| ------------------------------- | |
| procedure Validate_Invocation_Graph (G : Invocation_Graph) is | |
| begin | |
| pragma Assert (Present (G)); | |
| -- Nothing to do when switch -d_V (validate bindo cycles, graphs, and | |
| -- order) is not in effect. | |
| if not Debug_Flag_Underscore_VV then | |
| return; | |
| end if; | |
| Start_Phase (Invocation_Graph_Validation); | |
| Validate_Invocation_Graph_Vertices (G); | |
| Validate_Invocation_Graph_Edges (G); | |
| End_Phase (Invocation_Graph_Validation); | |
| if Has_Invalid_Data then | |
| raise Invalid_Invocation_Graph; | |
| end if; | |
| end Validate_Invocation_Graph; | |
| ------------------------------------ | |
| -- Validate_Invocation_Graph_Edge -- | |
| ------------------------------------ | |
| procedure Validate_Invocation_Graph_Edge | |
| (G : Invocation_Graph; | |
| Edge : Invocation_Graph_Edge_Id) | |
| is | |
| Msg : constant String := "Validate_Invocation_Graph_Edge"; | |
| begin | |
| pragma Assert (Present (G)); | |
| if not Present (Edge) then | |
| Write_Error (Msg, Has_Invalid_Data); | |
| Write_Str (" empty invocation graph edge"); | |
| Write_Eol; | |
| Write_Eol; | |
| return; | |
| end if; | |
| if not Present (Relation (G, Edge)) then | |
| Write_Error (Msg, Has_Invalid_Data); | |
| Write_Str (" invocation graph edge (IGE_Id_"); | |
| Write_Int (Int (Edge)); | |
| Write_Str (") lacks Relation"); | |
| Write_Eol; | |
| Write_Eol; | |
| end if; | |
| if not Present (Target (G, Edge)) then | |
| Write_Error (Msg, Has_Invalid_Data); | |
| Write_Str (" invocation graph edge (IGE_Id_"); | |
| Write_Int (Int (Edge)); | |
| Write_Str (") lacks Target"); | |
| Write_Eol; | |
| Write_Eol; | |
| end if; | |
| end Validate_Invocation_Graph_Edge; | |
| ------------------------------------- | |
| -- Validate_Invocation_Graph_Edges -- | |
| ------------------------------------- | |
| procedure Validate_Invocation_Graph_Edges (G : Invocation_Graph) is | |
| Edge : Invocation_Graph_Edge_Id; | |
| Iter : Invocation_Graphs.All_Edge_Iterator; | |
| begin | |
| pragma Assert (Present (G)); | |
| Iter := Iterate_All_Edges (G); | |
| while Has_Next (Iter) loop | |
| Next (Iter, Edge); | |
| Validate_Invocation_Graph_Edge (G, Edge); | |
| end loop; | |
| end Validate_Invocation_Graph_Edges; | |
| -------------------------------------- | |
| -- Validate_Invocation_Graph_Vertex -- | |
| -------------------------------------- | |
| procedure Validate_Invocation_Graph_Vertex | |
| (G : Invocation_Graph; | |
| Vertex : Invocation_Graph_Vertex_Id) | |
| is | |
| Msg : constant String := "Validate_Invocation_Graph_Vertex"; | |
| begin | |
| pragma Assert (Present (G)); | |
| if not Present (Vertex) then | |
| Write_Error (Msg, Has_Invalid_Data); | |
| Write_Str (" empty invocation graph vertex"); | |
| Write_Eol; | |
| Write_Eol; | |
| return; | |
| end if; | |
| if not Present (Body_Vertex (G, Vertex)) then | |
| Write_Error (Msg, Has_Invalid_Data); | |
| Write_Str (" invocation graph vertex (IGV_Id_"); | |
| Write_Int (Int (Vertex)); | |
| Write_Str (") lacks Body_Vertex"); | |
| Write_Eol; | |
| Write_Eol; | |
| end if; | |
| if not Present (Construct (G, Vertex)) then | |
| Write_Error (Msg, Has_Invalid_Data); | |
| Write_Str (" invocation graph vertex (IGV_Id_"); | |
| Write_Int (Int (Vertex)); | |
| Write_Str (") lacks Construct"); | |
| Write_Eol; | |
| Write_Eol; | |
| end if; | |
| if not Present (Spec_Vertex (G, Vertex)) then | |
| Write_Error (Msg, Has_Invalid_Data); | |
| Write_Str (" invocation graph vertex (IGV_Id_"); | |
| Write_Int (Int (Vertex)); | |
| Write_Str (") lacks Spec_Vertex"); | |
| Write_Eol; | |
| Write_Eol; | |
| end if; | |
| end Validate_Invocation_Graph_Vertex; | |
| ---------------------------------------- | |
| -- Validate_Invocation_Graph_Vertices -- | |
| ---------------------------------------- | |
| procedure Validate_Invocation_Graph_Vertices (G : Invocation_Graph) is | |
| Iter : Invocation_Graphs.All_Vertex_Iterator; | |
| Vertex : Invocation_Graph_Vertex_Id; | |
| begin | |
| pragma Assert (Present (G)); | |
| Iter := Iterate_All_Vertices (G); | |
| while Has_Next (Iter) loop | |
| Next (Iter, Vertex); | |
| Validate_Invocation_Graph_Vertex (G, Vertex); | |
| end loop; | |
| end Validate_Invocation_Graph_Vertices; | |
| end Invocation_Graph_Validators; | |
| ------------------------------ | |
| -- Library_Graph_Validators -- | |
| ------------------------------ | |
| package body Library_Graph_Validators is | |
| Has_Invalid_Data : Boolean := False; | |
| -- Flag set when the library graph contains invalid data | |
| ----------------------- | |
| -- Local subprograms -- | |
| ----------------------- | |
| procedure Validate_Library_Graph_Edge | |
| (G : Library_Graph; | |
| Edge : Library_Graph_Edge_Id); | |
| pragma Inline (Validate_Library_Graph_Edge); | |
| -- Verify that the attributes of edge Edge of library graph G are | |
| -- properly set. | |
| procedure Validate_Library_Graph_Edges (G : Library_Graph); | |
| pragma Inline (Validate_Library_Graph_Edges); | |
| -- Verify that the attributes of all edges of library graph G are | |
| -- properly set. | |
| procedure Validate_Library_Graph_Vertex | |
| (G : Library_Graph; | |
| Vertex : Library_Graph_Vertex_Id); | |
| pragma Inline (Validate_Library_Graph_Vertex); | |
| -- Verify that the attributes of vertex Vertex of library graph G are | |
| -- properly set. | |
| procedure Validate_Library_Graph_Vertices (G : Library_Graph); | |
| pragma Inline (Validate_Library_Graph_Vertices); | |
| -- Verify that the attributes of all vertices of library graph G are | |
| -- properly set. | |
| ---------------------------- | |
| -- Validate_Library_Graph -- | |
| ---------------------------- | |
| procedure Validate_Library_Graph (G : Library_Graph) is | |
| begin | |
| pragma Assert (Present (G)); | |
| -- Nothing to do when switch -d_V (validate bindo cycles, graphs, and | |
| -- order) is not in effect. | |
| if not Debug_Flag_Underscore_VV then | |
| return; | |
| end if; | |
| Start_Phase (Library_Graph_Validation); | |
| Validate_Library_Graph_Vertices (G); | |
| Validate_Library_Graph_Edges (G); | |
| End_Phase (Library_Graph_Validation); | |
| if Has_Invalid_Data then | |
| raise Invalid_Library_Graph; | |
| end if; | |
| end Validate_Library_Graph; | |
| --------------------------------- | |
| -- Validate_Library_Graph_Edge -- | |
| --------------------------------- | |
| procedure Validate_Library_Graph_Edge | |
| (G : Library_Graph; | |
| Edge : Library_Graph_Edge_Id) | |
| is | |
| Msg : constant String := "Validate_Library_Graph_Edge"; | |
| begin | |
| pragma Assert (Present (G)); | |
| if not Present (Edge) then | |
| Write_Error (Msg, Has_Invalid_Data); | |
| Write_Str (" empty library graph edge"); | |
| Write_Eol; | |
| Write_Eol; | |
| return; | |
| end if; | |
| if Kind (G, Edge) = No_Edge then | |
| Write_Error (Msg, Has_Invalid_Data); | |
| Write_Str (" library graph edge (LGE_Id_"); | |
| Write_Int (Int (Edge)); | |
| Write_Str (") is not a valid edge"); | |
| Write_Eol; | |
| Write_Eol; | |
| elsif Kind (G, Edge) = Body_Before_Spec_Edge then | |
| Write_Error (Msg, Has_Invalid_Data); | |
| Write_Str (" library graph edge (LGE_Id_"); | |
| Write_Int (Int (Edge)); | |
| Write_Str (") is a Body_Before_Spec edge"); | |
| Write_Eol; | |
| Write_Eol; | |
| end if; | |
| if not Present (Predecessor (G, Edge)) then | |
| Write_Error (Msg, Has_Invalid_Data); | |
| Write_Str (" library graph edge (LGE_Id_"); | |
| Write_Int (Int (Edge)); | |
| Write_Str (") lacks Predecessor"); | |
| Write_Eol; | |
| Write_Eol; | |
| end if; | |
| if not Present (Successor (G, Edge)) then | |
| Write_Error (Msg, Has_Invalid_Data); | |
| Write_Str (" library graph edge (LGE_Id_"); | |
| Write_Int (Int (Edge)); | |
| Write_Str (") lacks Successor"); | |
| Write_Eol; | |
| Write_Eol; | |
| end if; | |
| end Validate_Library_Graph_Edge; | |
| ---------------------------------- | |
| -- Validate_Library_Graph_Edges -- | |
| ---------------------------------- | |
| procedure Validate_Library_Graph_Edges (G : Library_Graph) is | |
| Edge : Library_Graph_Edge_Id; | |
| Iter : Library_Graphs.All_Edge_Iterator; | |
| begin | |
| pragma Assert (Present (G)); | |
| Iter := Iterate_All_Edges (G); | |
| while Has_Next (Iter) loop | |
| Next (Iter, Edge); | |
| Validate_Library_Graph_Edge (G, Edge); | |
| end loop; | |
| end Validate_Library_Graph_Edges; | |
| ----------------------------------- | |
| -- Validate_Library_Graph_Vertex -- | |
| ----------------------------------- | |
| procedure Validate_Library_Graph_Vertex | |
| (G : Library_Graph; | |
| Vertex : Library_Graph_Vertex_Id) | |
| is | |
| Msg : constant String := "Validate_Library_Graph_Vertex"; | |
| begin | |
| pragma Assert (Present (G)); | |
| if not Present (Vertex) then | |
| Write_Error (Msg, Has_Invalid_Data); | |
| Write_Str (" empty library graph vertex"); | |
| Write_Eol; | |
| Write_Eol; | |
| return; | |
| end if; | |
| if (Is_Body_With_Spec (G, Vertex) | |
| or else | |
| Is_Spec_With_Body (G, Vertex)) | |
| and then not Present (Corresponding_Item (G, Vertex)) | |
| then | |
| Write_Error (Msg, Has_Invalid_Data); | |
| Write_Str (" library graph vertex (LGV_Id_"); | |
| Write_Int (Int (Vertex)); | |
| Write_Str (") lacks Corresponding_Item"); | |
| Write_Eol; | |
| Write_Eol; | |
| end if; | |
| if not Present (Unit (G, Vertex)) then | |
| Write_Error (Msg, Has_Invalid_Data); | |
| Write_Str (" library graph vertex (LGV_Id_"); | |
| Write_Int (Int (Vertex)); | |
| Write_Str (") lacks Unit"); | |
| Write_Eol; | |
| Write_Eol; | |
| end if; | |
| end Validate_Library_Graph_Vertex; | |
| ------------------------------------- | |
| -- Validate_Library_Graph_Vertices -- | |
| ------------------------------------- | |
| procedure Validate_Library_Graph_Vertices (G : Library_Graph) is | |
| Iter : Library_Graphs.All_Vertex_Iterator; | |
| Vertex : Library_Graph_Vertex_Id; | |
| begin | |
| pragma Assert (Present (G)); | |
| Iter := Iterate_All_Vertices (G); | |
| while Has_Next (Iter) loop | |
| Next (Iter, Vertex); | |
| Validate_Library_Graph_Vertex (G, Vertex); | |
| end loop; | |
| end Validate_Library_Graph_Vertices; | |
| end Library_Graph_Validators; | |
| ----------------- | |
| -- Write_Error -- | |
| ----------------- | |
| procedure Write_Error | |
| (Msg : String; | |
| Flag : out Boolean) | |
| is | |
| begin | |
| Write_Str ("ERROR: "); | |
| Write_Str (Msg); | |
| Write_Eol; | |
| Flag := True; | |
| end Write_Error; | |
| end Bindo.Validators; |