Changeset 426


Ignore:
Timestamp:
Nov 10, 2015, 4:06:29 AM (7 years ago)
Author:
Maxim Reznik
Message:

Minor refactoring

Rename Count_Type to List in Gela.Peristent_Lists. Hide Index_Type

Location:
trunk/ada-2012/src/semantic
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/ada-2012/src/semantic/gela-name_list_managers.adb

    r415 r426  
    5454      pragma Unreferenced (Self);
    5555   begin
    56       return (Index => 0);
     56      return (Index => Pair_Peristent_Lists.Empty);
    5757   end Empty_List;
    5858
     
    7979         Name   : Gela.Elements.Defining_Names.Defining_Name_Access))
    8080   is
    81       use type Pair_Peristent_Lists.Count_Type;
     81      use type Pair_Peristent_Lists.List;
    8282
    83       Name   : Pair_Peristent_Lists.Count_Type := Input.Index;
     83      Name   : Pair_Peristent_Lists.List := Input.Index;
    8484   begin
    85       while Name > 0 loop
     85      while Name /= Pair_Peristent_Lists.Empty loop
    8686         Proc
    8787           (Self.Pair_List.Head (Name).Symbol,
     
    109109     (Self : Defining_Name_Cursor) return Boolean
    110110   is
    111       use type Pair_Peristent_Lists.Count_Type;
     111      use type Pair_Peristent_Lists.List;
    112112   begin
    113       return Self.Name > 0;
     113      return Self.Name /= Pair_Peristent_Lists.Empty;
    114114   end Has_Element;
    115115
     
    123123   is
    124124      use type Gela.Lexical_Types.Symbol;
    125       use type Pair_Peristent_Lists.Count_Type;
     125      use type Pair_Peristent_Lists.List;
    126126   begin
    127       while Self.Name > 0
     127      while Self.Name /= Pair_Peristent_Lists.Empty
    128128        and then Self.Set.Pair_List.Head (Self.Name).Symbol /= Symbol
    129129      loop
  • trunk/ada-2012/src/semantic/gela-name_list_managers.ads

    r415 r426  
    6363
    6464   type List is record
    65       Index : Pair_Peristent_Lists.Count_Type;
     65      Index : Pair_Peristent_Lists.List;
    6666   end record;
    6767
     
    7676      record
    7777         Set    : access Name_List_Manager'Class;
    78          Name   : Pair_Peristent_Lists.Count_Type := 0;
     78         Name   : Pair_Peristent_Lists.List := Pair_Peristent_Lists.Empty;
    7979      end record;
    8080
  • trunk/ada-2012/src/semantic/gela-peristent_lists.adb

    r415 r426  
    77   procedure Delete
    88     (Self   : in out Container;
    9       Input  : Count_Type;
     9      Input  : List;
    1010      Value  : Element_Type;
    11       Output : out Count_Type)
     11      Output : out List)
    1212   is
    1313      procedure Count_Each (Item : Element_Type);
     
    6161   procedure For_Each
    6262     (Self   : Container;
    63       Input  : Count_Type;
     63      Input  : List;
    6464      Action : access procedure (Value : Element_Type))
    6565   is
    66       Index : Count_Type := Input;
     66      Index : List := Input;
    6767   begin
    6868      while Index /= 0 loop
     
    8282   function Head
    8383     (Self   : Container;
    84       Index  : Index_Type)
    85       return Element_Type
     84      Index  : List) return Element_Type
    8685   is
    8786      X : constant Link := Self.Links.Element (Index);
     
    9796     (Self   : in out Container;
    9897      Value  : Element_Type;
    99       Input  : Count_Type := 0;
    100       Output : out Index_Type)
     98      Input  : List := Empty;
     99      Output : out List)
    101100   is
    102101      Value_Index : Natural := Self.Elements.Find_Index (Value);
    103102      New_Link    : Link;
    104       Result      : Count_Type;
     103      Result      : List;
    105104   begin
    106105      if Value_Index = 0 then
     
    126125   function Tail
    127126     (Self   : Container;
    128       Index  : Index_Type) return Count_Type is
     127      Index  : List) return List is
    129128   begin
    130129      return Self.Links.Element (Index).Next;
  • trunk/ada-2012/src/semantic/gela-peristent_lists.ads

    r415 r426  
    1010   --  Store actual values of Element_Type
    1111
    12    type Count_Type is new Natural;
    13    --  Represent persistent list (empty for 0 or not otherwise)
    14    subtype Index_Type is Count_Type range 1 .. Count_Type'Last;
    15    --  Represent non-empty persistent list
     12   type List is private;
     13   --  Represent persistent list
     14
     15   Empty : constant List;  --  Represent empty persistent list
    1616
    1717   procedure Prepend
    1818     (Self   : in out Container;
    1919      Value  : Element_Type;
    20       Input  : Count_Type := 0;
    21       Output : out Index_Type);
     20      Input  : List := Empty;
     21      Output : out List);
    2222
    2323   function Head
    2424     (Self   : Container;
    25       Index  : Index_Type) return Element_Type;
     25      Index  : List) return Element_Type;
    2626
    2727   function Tail
    2828     (Self   : Container;
    29       Index  : Index_Type) return Count_Type;
     29      Index  : List) return List;
    3030
    3131   procedure Delete
    3232     (Self   : in out Container;
    33       Input  : Count_Type;
     33      Input  : List;
    3434      Value  : Element_Type;
    35       Output : out Count_Type);
     35      Output : out List);
    3636
    3737   procedure For_Each
    3838     (Self   : Container;
    39       Input  : Count_Type;
     39      Input  : List;
    4040      Action : access procedure (Value : Element_Type));
    4141
    4242private
     43
     44   type List is new Natural;
     45   --  Represent persistent list (empty for 0 or not otherwise)
     46
     47   Empty : constant List := 0;
    4348
    4449   package Element_Vectors is new
     
    4752   type Link is record
    4853      Value : Positive;
    49       Next  : Count_Type;
     54      Next  : List;
    5055   end record;
     56
     57   subtype Index_Type is List range 1 .. List'Last;
     58   --  Represent non-empty persistent list
    5159
    5260   package Link_Vectors is new
  • trunk/ada-2012/src/semantic/gela-plain_environments-debug.adb

    r415 r426  
    88
    99   procedure Print_Region
    10      (Index : Region_Enum; List : Region_Item_Count);
     10     (Index : Region_Enum; List : Region_Item_List);
    1111
    1212   procedure Print (Item : Region_Item);
     
    4848   ------------------
    4949
    50    procedure Print_Region (Index : Region_Enum; List : Region_Item_Count) is
     50   procedure Print_Region (Index : Region_Enum; List : Region_Item_List) is
    5151   begin
    5252      Puts (Region_Enum'Image (Index) & ASCII.NUL);
  • trunk/ada-2012/src/semantic/gela-plain_environments.adb

    r419 r426  
    77      Index : Gela.Semantic_Types.Env_Index;
    88      Name  : Gela.Elements.Defining_Names.Defining_Name_Access)
    9          return Region_Item_Count;
     9         return Region_Item_List;
    1010
    1111   package Visible_Cursors is
     
    3131        (Self   : in out Defining_Name_Cursor'Class;
    3232         Symbol : Gela.Lexical_Types.Symbol;
    33          Region : Region_Item_Index);
     33         Region : Region_Item_List);
    3434   end Visible_Cursors;
    3535
     
    5757        (Self   : in out Defining_Name_Cursor'Class;
    5858         Symbol : Gela.Lexical_Types.Symbol;
    59          Region : Region_Item_Index)
     59         Region : Region_Item_List)
    6060      is
    6161         Local  : constant Gela.Name_List_Managers.List :=
     
    7272        new Visible_Cursors.Defining_Name_Cursor with
    7373         record
    74             Region  : Region_Item_Index;
     74            Region  : Region_Item_List;
    7575         end record;
    7676
     
    9090
    9191      overriding procedure Next (Self : in out Defining_Name_Cursor) is
     92         use type Region_Item_List;
    9293         Symbol : constant Gela.Lexical_Types.Symbol := Self.Current.Symbol;
    93          Region : Region_Item_Count;
     94         Region : Region_Item_List;
    9495      begin
    9596         Visible_Cursors.Defining_Name_Cursor (Self).Next;
     
    9899            Region := Self.Set.Region.Tail (Self.Region);
    99100
    100             if Region in Region_Item_Index then
     101            if Region /= Region_Item_Lists.Empty then
    101102               Self.Region := Region;
    102103               Visible_Cursors.Initialize (Self, Symbol, Region);
     
    115116         Symbol : Gela.Lexical_Types.Symbol)
    116117      is
    117          Region : Region_Item_Count := Self.Region;
    118       begin
    119          while Region in Region_Item_Index loop
     118         use type Region_Item_List;
     119         Region : Region_Item_List := Self.Region;
     120      begin
     121         while Region /= Region_Item_Lists.Empty loop
    120122            Self.Region := Region;
    121123            Visible_Cursors.Initialize (Self, Symbol, Region);
     
    134136         record
    135137            Env      : Env_Item_Index;
    136             Region   : Region_Item_Count;
     138            Region   : Region_Item_List;
    137139            --  Position in Env_Item.Nested_Region_List list
    138             Use_Name : Defining_Name_Item_Count;
     140            Use_Name : Defining_Name_List;
    139141            --  Position in Region.Use_Package list
    140142         end record;
     
    146148        (Self : Defining_Name_Cursor;
    147149         Name : Gela.Elements.Defining_Names.Defining_Name_Access)
    148          return Region_Item_Count;
     150         return Region_Item_List;
    149151
    150152      procedure Initialize
     
    161163
    162164      overriding procedure Next (Self : in out Defining_Name_Cursor) is
    163          use type Region_Item_Count;
    164          use type Defining_Name_Item_Count;
     165         use type Region_Item_List;
     166         use type Defining_Name_List;
    165167
    166168         Symbol : constant Gela.Lexical_Types.Symbol := Self.Current.Symbol;
    167          Region : Region_Item_Count;
     169         Region : Region_Item_List;
    168170      begin
    169171         Visible_Cursors.Defining_Name_Cursor (Self).Next;
    170172
    171173         while not Self.Current.Has_Element loop
    172             Region := 0;
    173 
    174             while Region = 0 loop
     174            Region := Region_Item_Lists.Empty;
     175
     176            while Region = Region_Item_Lists.Empty loop
    175177               --  Next name in use clauses of Region
    176178               Self.Use_Name := Self.Set.Use_Package.Tail (Self.Use_Name);
    177179
    178                while Self.Use_Name = 0 loop
     180               while Self.Use_Name = Defining_Name_Lists.Empty loop
    179181                  Self.Region := Self.Set.Region.Tail (Self.Region);
    180182
    181                   if Self.Region = 0 then
     183                  if Self.Region = Region_Item_Lists.Empty then
    182184                     return;
    183185                  end if;
     
    202204        (Self : Defining_Name_Cursor;
    203205         Name : Gela.Elements.Defining_Names.Defining_Name_Access)
    204          return Region_Item_Count is
     206         return Region_Item_List is
    205207      begin
    206208         return Name_To_Region (Self.Set, Self.Env, Name);
     
    215217         Symbol : Gela.Lexical_Types.Symbol)
    216218      is
    217          use type Region_Item_Count;
    218          use type Defining_Name_Item_Count;
     219         use type Region_Item_List;
     220         use type Defining_Name_List;
    219221
    220222         Env    : constant Env_Item := Self.Set.Env.Element (Self.Env);
    221          Target : Region_Item_Count;
     223         Target : Region_Item_List;
    222224         Local  : Gela.Name_List_Managers.List;
    223225      begin
    224226         Self.Region := Env.Region_List (Nested);
    225227
    226          while Self.Region /= 0 loop
     228         while Self.Region /= Region_Item_Lists.Empty loop
    227229            Self.Use_Name := Self.Set.Region.Head (Self.Region).Use_Package;
    228230
    229             while Self.Use_Name /= 0 loop
     231            while Self.Use_Name /= Defining_Name_Lists.Empty loop
    230232               Target := Self.Name_To_Region
    231233                 (Self.Set.Use_Package.Head (Self.Use_Name));
    232234
    233                if Target /= 0 then
     235               if Target /= Region_Item_Lists.Empty then
    234236                  Local := Self.Set.Region.Head (Target).Local;
    235237                  Self.Current := Self.Set.Names.Find (Local, Symbol);
     
    304306      return Gela.Environments.Completion_List
    305307   is
    306       use type Region_Item_Count;
     308      use type Region_Item_List;
    307309      use type Gela.Elements.Defining_Names.Defining_Name_Access;
    308310
    309311      procedure Find_Completion
    310         (List    : Defining_Name_Item_Count;
     312        (List    : Defining_Name_List;
    311313         Result  : out Gela.Elements.Defining_Names.Defining_Name_Access;
    312314         Restart : in out Boolean);
     
    317319
    318320      procedure Find_Completion
    319         (List    : Defining_Name_Item_Count;
     321        (List    : Defining_Name_List;
    320322         Result  : out Gela.Elements.Defining_Names.Defining_Name_Access;
    321323         Restart : in out Boolean)
    322324      is
    323          use type Defining_Name_Item_Count;
    324          Next   : Defining_Name_Item_Count := List;
     325         use type Defining_Name_List;
     326         Next   : Defining_Name_List := List;
    325327         Completion : Gela.Elements.Defining_Names.Defining_Name_Access;
    326328      begin
    327          while Next /= 0 loop
     329         while Next /= Defining_Name_Lists.Empty loop
    328330            Result := Self.Use_Package.Head (Next);
    329331            Next := Self.Use_Package.Tail (Next);
     
    344346
    345347      Env     : constant Env_Item := Self.Env.Element (Index);
    346       Next    : Region_Item_Count;
     348      Next    : Region_Item_List;
    347349      Result  : Gela.Elements.Defining_Names.Defining_Name_Access;
    348350      Data    : Gela.Environments.Completion_Array
     
    353355      for J of Env.Region_List loop
    354356         Next := J;
    355          while Next /= 0 loop
     357         while Next /= Region_Item_Lists.Empty loop
    356358            Find_Completion
    357359              (Self.Region.Head (Next).Completion, Result, Restart);
     
    382384      return Gela.Semantic_Types.Env_Index
    383385   is
    384       use type Region_Item_Count;
     386      use type Region_Item_List;
    385387
    386388      procedure Update_Lib_Unit_Env
     
    414416         Env := Self.Env.Element (Index);
    415417      else
    416          Env := (Region_List => (Nested => 0, Other => 0, Withed => 0));
    417       end if;
    418 
    419       if Env.Region_List (Nested) = 0 then
     418         Env := (Region_List =>
     419                   (Nested | Other | Withed => Region_Item_Lists.Empty));
     420      end if;
     421
     422      if Env.Region_List (Nested) = Region_Item_Lists.Empty then
    420423         Reg := (Name => null,
    421424                 Local => Self.Names.Empty_List,
    422                  Use_Package | Completion => 0);
     425                 Use_Package | Completion => Defining_Name_Lists.Empty);
    423426      else
    424427         Reg := Self.Region.Head (Env.Region_List (Nested));
     
    431434         Output => Reg.Local);
    432435
    433       if Env.Region_List (Nested) = 0 then
     436      if Env.Region_List (Nested) = Region_Item_Lists.Empty then
    434437         --  Create Nested_Region_List as (Reg)
    435438         Self.Region.Prepend
    436439           (Value  => Reg,
    437             Input  => 0,
     440            Input  => Region_Item_Lists.Empty,
    438441            Output => Env.Region_List (Nested));
    439442      else
     
    518521        Self.Library_Unit_Environment (Symbol);
    519522      Target_Env : Env_Item;
    520       List   : Region_Item_Count;
     523      List   : Region_Item_List;
    521524
    522525      procedure Append (Item : Region_Item) is
     
    607610      return Gela.Semantic_Types.Env_Index
    608611   is
     612      use type Region_Item_List;
    609613      Env   : Env_Item;
    610614      Found : Gela.Semantic_Types.Env_Index;
    611       Spec  : constant Region_Item_Count :=
     615      Spec  : constant Region_Item_List :=
    612616        Name_To_Region (Self, Index, Region);
    613617      Next  : Region_Item :=
    614618        (Name        => Region,
    615619         Local       => Self.Names.Empty_List,
    616          Use_Package => 0,
    617          Completion  => 0);
     620         Use_Package => Defining_Name_Lists.Empty,
     621         Completion  => Defining_Name_Lists.Empty);
    618622   begin
    619623      if Index in Env_Item_Index then
    620624         Env := Self.Env.Element (Index);
    621625      else
    622          Env := (Region_List => (Nested => 0, Other => 0, Withed => 0));
    623       end if;
    624 
    625       if Spec in Region_Item_Index then
     626         Env := (Region_List =>
     627                   (Nested | Other | Withed => Region_Item_Lists.Empty));
     628      end if;
     629
     630      if Spec /= Region_Item_Lists.Empty then
    626631         Next := Self.Region.Head (Spec);
    627632      end if;
     
    659664        (Name        => Region,
    660665         Local       => Self.Names.Empty_List,
    661          Use_Package => 0,
    662          Completion  => 0);
     666         Use_Package => Defining_Name_Lists.Empty,
     667         Completion  => Defining_Name_Lists.Empty);
    663668   begin
    664669      if Index in Env_Item_Index then
    665670         Env := Self.Env.Element (Index);
    666671      else
    667          Env := (Region_List => (Nested => 0, Other => 0, Withed => 0));
     672         Env := (Region_List =>
     673                   (Nested | Other | Withed => Region_Item_Lists.Empty));
    668674      end if;
    669675
     
    779785      Index : Gela.Semantic_Types.Env_Index;
    780786      Name  : Gela.Elements.Defining_Names.Defining_Name_Access)
    781          return Region_Item_Count
    782    is
    783       use type Region_Item_Count;
     787         return Region_Item_List
     788   is
     789      use type Region_Item_List;
    784790      use type Gela.Elements.Defining_Names.Defining_Name_Access;
    785791
    786792      Env  : constant Env_Item := Self.Env.Element (Index);
    787       Next : Region_Item_Count;
     793      Next : Region_Item_List;
    788794   begin
    789795      for J of Env.Region_List loop
    790796         Next := J;
    791          while Next /= 0 loop
     797         while Next /= Region_Item_Lists.Empty loop
    792798            if Self.Region.Head (Next).Name = Name then
    793799               return Next;
     
    798804      end loop;
    799805
    800       return 0;
     806      return Region_Item_Lists.Empty;
    801807   end Name_To_Region;
    802808
     
    831837        (Set      => Plain_Environment_Set_Access (Self),
    832838         Env      => Index,
    833          Region   => 0,
    834          Use_Name => 0,
     839         Region   => Region_Item_Lists.Empty,
     840         Use_Name => Defining_Name_Lists.Empty,
    835841         others   => <>)
    836842      do
     
    852858   is
    853859      use type Gela.Lexical_Types.Symbol;
    854 
    855       Item : Region_Item_Count;
     860      use type Region_Item_List;
     861
     862      Item : Region_Item_List;
    856863   begin
    857864      Found.all := False;
     
    874881      end if;
    875882
    876       if Item not in Region_Item_Index then
     883      if Item = Region_Item_Lists.Empty then
    877884         return None : constant Visible_Cursors.Defining_Name_Cursor :=
    878885           (others => <>);
  • trunk/ada-2012/src/semantic/gela-plain_environments.ads

    r419 r426  
    2525     (Element_Type => Gela.Elements.Defining_Names.Defining_Name_Access);
    2626
    27    subtype Defining_Name_Item_Count is Defining_Name_Lists.Count_Type;
    28    subtype Defining_Name_Item_Index is Defining_Name_Lists.Index_Type;
     27   subtype Defining_Name_List is Defining_Name_Lists.List;
    2928
    3029   --  Region_Item  --
     
    3534      Local : Gela.Name_List_Managers.List;
    3635      --  List of Direct_Visible_Item.
    37       Use_Package : Defining_Name_Item_Count;
     36      Use_Package : Defining_Name_List;
    3837      --  List of use_package_clauses in the region
    39       Completion : Defining_Name_Item_Count;
     38      Completion : Defining_Name_List;
    4039      --  List of <Completion, Name> pairs
    4140   end record;
     
    4443     (Element_Type => Region_Item);
    4544
    46    subtype Region_Item_Count is Region_Item_Lists.Count_Type;
    47    subtype Region_Item_Index is Region_Item_Lists.Index_Type;
     45   subtype Region_Item_List is Region_Item_Lists.List;
    4846
    4947   --  Env_Item  --
     
    5452   --  Withed - List of regions available over with clauses
    5553
    56    type Region_List_Array is array (Region_Enum) of Region_Item_Count;
     54   type Region_List_Array is array (Region_Enum) of Region_Item_List;
    5755
    5856   type Env_Item is record
Note: See TracChangeset for help on using the changeset viewer.