diff options
Diffstat (limited to 'src/synth/netlists-iterators.adb')
| -rw-r--r-- | src/synth/netlists-iterators.adb | 387 |
1 files changed, 387 insertions, 0 deletions
diff --git a/src/synth/netlists-iterators.adb b/src/synth/netlists-iterators.adb new file mode 100644 index 000000000..babf74eb8 --- /dev/null +++ b/src/synth/netlists-iterators.adb @@ -0,0 +1,387 @@ +-- Iterators for elements of a netlist. +-- Copyright (C) 2017 Tristan Gingold +-- +-- This file is part of GHDL. +-- +-- This program is free software; you can redistribute it and/or modify +-- it under the terms of the GNU General Public License as published by +-- the Free Software Foundation; either version 2 of the License, or +-- (at your option) any later version. +-- +-- This program is distributed in the hope that it will be useful, +-- but WITHOUT 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 +-- along with this program; if not, write to the Free Software +-- Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, +-- MA 02110-1301, USA. + +with Netlists.Utils; use Netlists.Utils; + +package body Netlists.Iterators is + function Sub_Modules (M : Module) return Modules_Iterator + is + pragma Assert (Is_Valid (M)); + begin + return Modules_Iterator'(M => M); + end Sub_Modules; + + function Modules_First (It : Modules_Iterator) return Modules_Cursor is + begin + return Modules_Cursor'(M => Get_First_Sub_Module (It.M)); + end Modules_First; + + function Modules_Next (It : Modules_Iterator; Cur : Modules_Cursor) + return Modules_Cursor + is + pragma Unreferenced (It); + begin + return Modules_Cursor'(M => Get_Next_Sub_Module (Cur.M)); + end Modules_Next; + + function Modules_Has_Element (It : Modules_Iterator; Cur : Modules_Cursor) + return Boolean + is + pragma Unreferenced (It); + begin + return Cur.M /= No_Module; + end Modules_Has_Element; + + function Modules_Element (It : Modules_Iterator; Cur : Modules_Cursor) + return Module + is + pragma Unreferenced (It); + begin + return Cur.M; + end Modules_Element; + + function Ports_Desc_First (It : Ports_Desc_Iterator) + return Ports_Desc_Cursor is + begin + return Ports_Desc_Cursor' + (Idx => Get_First_Port_Desc (It.M), + Num => Get_Nbr_Inputs (It.M) + Get_Nbr_Outputs (It.M)); + end Ports_Desc_First; + + function Ports_Desc_Next (It : Ports_Desc_Iterator; Cur : Ports_Desc_Cursor) + return Ports_Desc_Cursor + is + pragma Unreferenced (It); + begin + return Ports_Desc_Cursor'(Idx => Cur.Idx + 1, + Num => Cur.Num - 1); + end Ports_Desc_Next; + + function Ports_Desc_Has_Element + (It : Ports_Desc_Iterator; Cur : Ports_Desc_Cursor) return Boolean + is + pragma Unreferenced (It); + begin + return Cur.Num > 0; + end Ports_Desc_Has_Element; + + function Ports_Desc_Element + (It : Ports_Desc_Iterator; Cur : Ports_Desc_Cursor) return Port_Desc + is + pragma Unreferenced (It); + begin + return Get_Port_Desc (Cur.Idx); + end Ports_Desc_Element; + + function Ports_Desc (M : Module) return Ports_Desc_Iterator + is + pragma Assert (Is_Valid (M)); + begin + return Ports_Desc_Iterator'(M => M); + end Ports_Desc; + + function Params_Desc_First (It : Params_Desc_Iterator) + return Params_Desc_Cursor is + begin + return Params_Desc_Cursor' + (Idx => 0, + Num => Get_Nbr_Params (It.M)); + end Params_Desc_First; + + function Params_Desc_Next + (It : Params_Desc_Iterator; Cur : Params_Desc_Cursor) + return Params_Desc_Cursor + is + pragma Unreferenced (It); + begin + return Params_Desc_Cursor'(Idx => Cur.Idx + 1, + Num => Cur.Num - 1); + end Params_Desc_Next; + + function Params_Desc_Has_Element + (It : Params_Desc_Iterator; Cur : Params_Desc_Cursor) return Boolean + is + pragma Unreferenced (It); + begin + return Cur.Num > 0; + end Params_Desc_Has_Element; + + function Params_Desc_Element + (It : Params_Desc_Iterator; Cur : Params_Desc_Cursor) return Param_Desc is + begin + return Get_Param_Desc (It.M, Cur.Idx); + end Params_Desc_Element; + + function Params_Desc (M : Module) return Params_Desc_Iterator is + begin + return Params_Desc_Iterator'(M => M); + end Params_Desc; + + function Instances_First (It : Instances_Iterator) + return Instances_Cursor is + begin + return Instances_Cursor'(Inst => Get_First_Instance (It.M)); + end Instances_First; + + function Instances_Next (It : Instances_Iterator; Cur : Instances_Cursor) + return Instances_Cursor + is + pragma Unreferenced (It); + begin + return Instances_Cursor'(Inst => Get_Next_Instance (Cur.Inst)); + end Instances_Next; + + function Instances_Has_Element + (It : Instances_Iterator; Cur : Instances_Cursor) return Boolean + is + pragma Unreferenced (It); + begin + return Cur.Inst /= No_Instance; + end Instances_Has_Element; + + function Instances_Element + (It : Instances_Iterator; Cur : Instances_Cursor) return Instance + is + pragma Unreferenced (It); + begin + return Cur.Inst; + end Instances_Element; + + function Instances (M : Module) return Instances_Iterator is + begin + return Instances_Iterator'(M => M); + end Instances; + + function Inputs_First (It : Inputs_Iterator) return Inputs_Cursor is + begin + return Inputs_Cursor'(Idx => 0, + Nbr => Get_Nbr_Inputs (It.Inst)); + end Inputs_First; + + function Inputs_Next (It : Inputs_Iterator; Cur : Inputs_Cursor) + return Inputs_Cursor + is + pragma Unreferenced (It); + begin + return Inputs_Cursor'(Idx => Cur.Idx + 1, + Nbr => Cur.Nbr); + end Inputs_Next; + + function Inputs_Has_Element (It : Inputs_Iterator; Cur : Inputs_Cursor) + return Boolean + is + pragma Unreferenced (It); + begin + return Cur.Idx < Cur.Nbr; + end Inputs_Has_Element; + + function Inputs_Element (It : Inputs_Iterator; Cur : Inputs_Cursor) + return Input is + begin + return Get_Input (It.Inst, Cur.Idx); + end Inputs_Element; + + function Inputs (Inst : Instance) return Inputs_Iterator is + begin + return Inputs_Iterator'(Inst => Inst); + end Inputs; + + function Outputs_First (It : Outputs_Iterator) return Outputs_Cursor is + begin + return Outputs_Cursor'(Idx => 0, + Nbr => Get_Nbr_Outputs (It.Inst)); + end Outputs_First; + + function Outputs_Next (It : Outputs_Iterator; Cur : Outputs_Cursor) + return Outputs_Cursor + is + pragma Unreferenced (It); + begin + return Outputs_Cursor'(Idx => Cur.Idx + 1, + Nbr => Cur.Nbr); + end Outputs_Next; + + function Outputs_Has_Element (It : Outputs_Iterator; Cur : Outputs_Cursor) + return Boolean + is + pragma Unreferenced (It); + begin + return Cur.Idx < Cur.Nbr; + end Outputs_Has_Element; + + function Outputs_Element (It : Outputs_Iterator; Cur : Outputs_Cursor) + return Net is + begin + return Get_Output (It.Inst, Cur.Idx); + end Outputs_Element; + + function Outputs (Inst : Instance) return Outputs_Iterator is + begin + return Outputs_Iterator'(Inst => Inst); + end Outputs; + + function Params_First (It : Params_Iterator) return Params_Cursor is + begin + return Params_Cursor'(Idx => 0, + Nbr => Get_Nbr_Params (It.Inst)); + end Params_First; + + function Params_Next (It : Params_Iterator; Cur : Params_Cursor) + return Params_Cursor + is + pragma Unreferenced (It); + begin + return Params_Cursor'(Idx => Cur.Idx + 1, + Nbr => Cur.Nbr - 1); + end Params_Next; + + function Params_Has_Element (It : Params_Iterator; Cur : Params_Cursor) + return Boolean + is + pragma Unreferenced (It); + begin + return Cur.Nbr > 0; + end Params_Has_Element; + + function Params (Inst : Instance) return Params_Iterator is + begin + return Params_Iterator'(Inst => Inst); + end Params; + + function Get_Param_Idx (Cur : Params_Cursor) return Param_Idx is + begin + return Cur.Idx; + end Get_Param_Idx; + + function Nets_First (It : Nets_Iterator) return Nets_Cursor + is + Inst : Instance; + Num : Port_Nbr; + begin + Inst := Get_Self_Instance (It.M); + loop + if Inst = No_Instance then + -- No instance. + return Nets_Cursor'(Inst => No_Instance, + N => No_Net, + Num => 0); + end if; + Num := Get_Nbr_Outputs (Inst); + if Num = 0 then + -- No output for this instance. + Inst := Get_Next_Instance (Inst); + else + return Nets_Cursor'(Inst => Inst, + N => Get_First_Output (Inst), + Num => Num); + end if; + end loop; + end Nets_First; + + function Nets_Next (It : Nets_Iterator; Cur : Nets_Cursor) + return Nets_Cursor + is + pragma Unreferenced (It); + begin + if Cur.Num > 1 then + return Nets_Cursor'(Inst => Cur.Inst, + N => Cur.N + 1, + Num => Cur.Num - 1); + else + declare + Inst : Instance; + Num : Port_Nbr; + begin + Inst := Cur.Inst; + loop + Inst := Get_Next_Instance (Inst); + exit when Inst = No_Instance; + Num := Get_Nbr_Outputs (Inst); + pragma Assert (Num > 0); + return Nets_Cursor'(Inst => Inst, + N => Get_First_Output (Inst), + Num => Num); + end loop; + end; + return Nets_Cursor'(Inst => No_Instance, + N => No_Net, + Num => 0); + end if; + end Nets_Next; + + function Nets_Has_Element (It : Nets_Iterator; Cur : Nets_Cursor) + return Boolean + is + pragma Unreferenced (It); + begin + return Cur.Num > 0 or Cur.Inst /= No_Instance; + end Nets_Has_Element; + + function Nets_Element (It : Nets_Iterator; Cur : Nets_Cursor) + return Net + is + pragma Unreferenced (It); + begin + return Cur.N; + end Nets_Element; + + function Nets (M : Module) return Nets_Iterator + is + pragma Assert (Is_Valid (M)); + begin + return Nets_Iterator'(M => M); + end Nets; + + function Sinks_First (It : Sinks_Iterator) return Sinks_Cursor is + begin + return Sinks_Cursor'(S => Get_First_Sink (It.N)); + end Sinks_First; + + function Sinks_Next (It : Sinks_Iterator; Cur : Sinks_Cursor) + return Sinks_Cursor + is + pragma Unreferenced (It); + begin + return Sinks_Cursor'(S => Get_Next_Sink (Cur.S)); + end Sinks_Next; + + function Sinks_Has_Element (It : Sinks_Iterator; Cur : Sinks_Cursor) + return Boolean + is + pragma Unreferenced (It); + begin + return Cur.S /= No_Input; + end Sinks_Has_Element; + + function Sinks_Element (It : Sinks_Iterator; Cur : Sinks_Cursor) + return Input + is + pragma Unreferenced (It); + begin + return Cur.S; + end Sinks_Element; + + function Sinks (N : Net) return Sinks_Iterator is + begin + pragma Assert (Is_Valid (N)); + return Sinks_Iterator'(N => N); + end Sinks; + +end Netlists.Iterators; |