Changeset 537


Ignore:
Timestamp:
Nov 12, 2017, 6:56:15 AM (5 years ago)
Author:
Maxim Reznik
Message:

Separate grammars library into its own package

New package is named Anagram.

Location:
trunk/ada-2012
Files:
4 deleted
29 edited

Legend:

Unmodified
Added
Removed
  • trunk/ada-2012/Makefile

    r415 r537  
    4545tests: asis
    4646        gprbuild -m -j0 -p -P gnat/gela_tester.gpr
    47         gprbuild -m -j0 -p -P gnat/gela_grammars_tests.gpr
    4847        gprbuild -m -j0 -p -P gnat/gela_tests.gpr
    4948        gprbuild -m -j0 -p -P gnat/gela_asis_tests.gpr
  • trunk/ada-2012/gnat/gela_ag.gpr

    r467 r537  
    11with "matreshka_league";
    22with "gela_common";
    3 with "gela_grammars";
     3with "anagram";
    44
    55project Gela_AG is
  • trunk/ada-2012/gnat/gela_build.gpr

    r467 r537  
    11with "matreshka_league";
    2 with "gela_grammars";
     2with "anagram";
    33with "gela_common";
    44
  • trunk/ada-2012/src/parser/gela-larl_parsers.adb

    r525 r537  
     1with Anagram.Grammars.LR_Parsers;
     2
    13with Gela.Element_Visiters;
    24with Gela.Elements.Associations;
     
    911with Gela.Elements.Selector_Names;
    1012with Gela.Elements.Subtype_Marks;
    11 with Gela.Grammars.LR_Parsers;
    1213with Gela.LARL_Parsers.Data;
    1314with Gela.LARL_Parsers.On_Reduce;
     
    1920
    2021   Map : constant array (Gela.Lexical_Types.Token_Kind)
    21      of Gela.Grammars.Terminal_Count :=
     22     of Anagram.Grammars.Terminal_Count :=
    2223     (Error                   => 0,
    2324      End_Of_Input            => 0,
     
    134135   procedure Next_Token
    135136     (Self  : access Input_Wrapper;
    136       Token : out Gela.Grammars.Terminal_Count;
     137      Token : out Anagram.Grammars.Terminal_Count;
    137138      Value : out Gela.LARL_Parsers_Nodes.Node);
    138139
     
    193194   procedure Next_Token
    194195     (Self  : access Input_Wrapper;
    195       Token : out Gela.Grammars.Terminal_Count;
     196      Token : out Anagram.Grammars.Terminal_Count;
    196197      Value : out Gela.LARL_Parsers_Nodes.Node)
    197198   is
     
    220221      pragma Unreferenced (Self);
    221222
    222       procedure Do_It is new Gela.Grammars.LR_Parsers.Parse
     223      procedure Do_It is new Anagram.Grammars.LR_Parsers.Parse
    223224        (Node        => Gela.LARL_Parsers_Nodes.Node,
    224225         Node_Array  => Gela.LARL_Parsers_Nodes.Node_Array,
     
    315316      return Gela.Elements.Subtype_Indications.Subtype_Indication_Access
    316317   is
    317       use type Gela.Elements.Constraints.Constraint_Access;
    318 
    319318      package Visiters is
    320319         type Visiter is new Gela.Element_Visiters.Visiter with record
  • trunk/ada-2012/tools/ag/ag_driver.adb

    r529 r537  
    1313with League.Strings;
    1414
    15 with Gela.Grammars;
     15with Anagram.Grammars;
    1616
    1717with AG_Tools; use AG_Tools;
    1818with AG_Tools.Writers; use AG_Tools.Writers;
    19 --  with Gela.Grammars_Debug;
     19--  with Anagram.Grammars_Debug;
    2020with AG_Tools.Input;
    2121with AG_Tools.Element_Generators;
     
    2727   use AG_Tools.Input;
    2828
    29    use type Gela.Grammars.Non_Terminal_Count;
     29   use type Anagram.Grammars.Non_Terminal_Count;
    3030   use type League.Strings.Universal_String;
    3131
     
    3434
    3535   Name  : constant String := Ada.Command_Line.Argument (1);
    36    G     : Gela.Grammars.Grammar_Access;
     36   G     : Anagram.Grammars.Grammar_Access;
    3737
    3838   procedure Generate_2 is
     
    259259   G := AG_Tools.Input.Grammar;
    260260
    261 --     Gela.Grammars_Debug.Print (G);
     261--     Anagram.Grammars_Debug.Print (G);
    262262
    263263--   Generate_Factory;
  • trunk/ada-2012/tools/ag/ag_tools-check_ordered.adb

    r529 r537  
    1010with Ada.Text_IO;
    1111
    12 with Gela.Grammars_Checks;
    13 with Gela.Grammars_Convertors;
    14 with Gela.Grammars.Ordered;
    15 --  with Gela.Grammars_Debug;
     12with Anagram.Grammars_Checks;
     13with Anagram.Grammars_Convertors;
     14with Anagram.Grammars.Ordered;
     15--  with Anagram.Grammars_Debug;
    1616
    1717with League.Strings;
     
    2525
    2626   procedure Generate2
    27      (G           : Gela.Grammars.Grammar_Access;
    28       Order       : Gela.Grammars.Ordered.Order_Maps.Map;
    29       Partitions  : Gela.Grammars.Ordered.Partition_Array);
     27     (G           : Anagram.Grammars.Grammar_Access;
     28      Order       : Anagram.Grammars.Ordered.Order_Maps.Map;
     29      Partitions  : Anagram.Grammars.Ordered.Partition_Array);
    3030
    3131   -----------
     
    3535   procedure Check is
    3636      Ok     : Boolean;
    37       Result : constant Gela.Grammars.Grammar_Access :=
    38         new Gela.Grammars.Grammar'
    39           (Gela.Grammars_Convertors.Convert_With_Empty
     37      Result : constant Anagram.Grammars.Grammar_Access :=
     38        new Anagram.Grammars.Grammar'
     39          (Anagram.Grammars_Convertors.Convert_With_Empty
    4040               (AG_Tools.Input.Grammar.all));
    4141
    42       Order  : Gela.Grammars.Ordered.Order_Maps.Map;
    43       Partitions : Gela.Grammars.Ordered.Partition_Array
     42      Order  : Anagram.Grammars.Ordered.Order_Maps.Map;
     43      Partitions : Anagram.Grammars.Ordered.Partition_Array
    4444        (Result.Declaration'Range);
    4545   begin
    46       --           Gela.Grammars_Debug.Print (G);
    47       --           Gela.Grammars_Debug.Print (Result.all);
     46      --           Anagram.Grammars_Debug.Print (G);
     47      --           Anagram.Grammars_Debug.Print (Result.all);
    4848
    49       Ok := Gela.Grammars_Checks.Is_Well_Formed (Result.all, True);
     49      Ok := Anagram.Grammars_Checks.Is_Well_Formed (Result.all, True);
    5050
    5151      if not Ok then
     
    5353      end if;
    5454
    55       Gela.Grammars.Ordered.Find_Order (Result.all, Ok, Partitions, Order);
     55      Anagram.Grammars.Ordered.Find_Order (Result.all, Ok, Partitions, Order);
    5656
    5757      if not Ok then
     
    6565      for J in Order.Iterate loop
    6666         declare
    67             Key : constant Gela.Grammars.Ordered.Key :=
    68               Gela.Grammars.Ordered.Order_Maps.Key (J);
    69             Item : constant Gela.Grammars.Ordered.Action :=
    70               Gela.Grammars.Ordered.Order_Maps.Element (J);
     67            Key : constant Anagram.Grammars.Ordered.Key :=
     68              Anagram.Grammars.Ordered.Order_Maps.Key (J);
     69            Item : constant Anagram.Grammars.Ordered.Action :=
     70              Anagram.Grammars.Ordered.Order_Maps.Element (J);
    7171         begin
    7272            Ada.Text_IO.Put
     
    8585
    8686            case Item.Kind is
    87                when Gela.Grammars.Ordered.Evaluate_Rule =>
     87               when Anagram.Grammars.Ordered.Evaluate_Rule =>
    8888                  Ada.Text_IO.Put_Line (Item.Rule'Img);
    8989                  Ada.Text_IO.Put_Line
    9090                    (Result.Rule (Item.Rule).Text.To_UTF_8_String);
    91                when Gela.Grammars.Ordered.Descent =>
     91               when Anagram.Grammars.Ordered.Descent =>
    9292                  Ada.Text_IO.Put
    9393                    (Result.Part (Item.Part).Name.
     
    105105
    106106   procedure Generate2
    107      (G           : Gela.Grammars.Grammar_Access;
    108       Order       : Gela.Grammars.Ordered.Order_Maps.Map;
    109       Partitions  : Gela.Grammars.Ordered.Partition_Array)
     107     (G           : Anagram.Grammars.Grammar_Access;
     108      Order       : Anagram.Grammars.Ordered.Order_Maps.Map;
     109      Partitions  : Anagram.Grammars.Ordered.Partition_Array)
    110110   is
    111       use Gela.Grammars;
     111      use Anagram.Grammars;
    112112      use type League.Strings.Universal_String;
    113113
     
    123123      Context.Grammar := G;
    124124      Context.Partition :=
    125         new Gela.Grammars.Ordered.Partition_Array'(Partitions);
     125        new Anagram.Grammars.Ordered.Partition_Array'(Partitions);
    126126      Context.Part_Map :=
    127127        new AG_Tools.Contexts.Part_Map'(G.Part'Range => False);
     
    160160         for NT of G.Non_Terminal loop
    161161            declare
    162                use Gela.Grammars.Ordered.Order_Maps;
     162               use Anagram.Grammars.Ordered.Order_Maps;
    163163               Pos : constant Cursor :=
    164164                 Order.Ceiling ((NT.First, Pass, Step => 1));
  • trunk/ada-2012/tools/ag/ag_tools-clone_generator.adb

    r513 r537  
    1919   ---------
    2020
    21    procedure Run (G : Gela.Grammars.Grammar_Access) is
     21   procedure Run (G : Anagram.Grammars.Grammar_Access) is
    2222      procedure Each_Part
    23         (Part   : Gela.Grammars.Part;
     23        (Part   : Anagram.Grammars.Part;
    2424         Decl   : in out Writer;
    2525         Assign : in out Writer;
     
    3535
    3636      procedure Each_Part
    37         (Part   : Gela.Grammars.Part;
     37        (Part   : Anagram.Grammars.Part;
    3838         Decl   : in out Writer;
    3939         Assign : in out Writer;
     
    6767         if Part.Is_List_Reference then
    6868            declare
    69                NT : constant Gela.Grammars.Non_Terminal_Index :=
     69               NT : constant Anagram.Grammars.Non_Terminal_Index :=
    7070                 List_Item (G.all, G.Non_Terminal (Part.Denote));
    7171            begin
     
    116116         else
    117117            declare
    118                NT : constant Gela.Grammars.Non_Terminal_Index := Part.Denote;
     118               NT : constant Anagram.Grammars.Non_Terminal_Index :=
     119                 Part.Denote;
    119120            begin
    120121               if not Is_Concrete (NT) and not Withed (NT) then
  • trunk/ada-2012/tools/ag/ag_tools-clone_generator.ads

    r466 r537  
    1010package AG_Tools.Clone_Generator is
    1111
    12    procedure Run (G : Gela.Grammars.Grammar_Access);
     12   procedure Run (G : Anagram.Grammars.Grammar_Access);
    1313
    1414end AG_Tools.Clone_Generator;
  • trunk/ada-2012/tools/ag/ag_tools-contexts.ads

    r415 r537  
    1212with League.String_Vectors;
    1313
    14 with Gela.Grammars.Ordered;
     14with Anagram.Grammars.Ordered;
    1515
    1616with AG_Tools.Visit_Generators;
     
    2020
    2121   type Partition_Array_Access is
    22      access all Gela.Grammars.Ordered.Partition_Array;
     22     access all Anagram.Grammars.Ordered.Partition_Array;
    2323
    24    type Part_Map is array (Gela.Grammars.Part_Index range <>) of Boolean;
     24   type Part_Map is array (Anagram.Grammars.Part_Index range <>) of Boolean;
    2525   type Part_Map_Access is access all Part_Map;
    2626
    2727   type Attr is record
    2828      Origin : League.Strings.Universal_String;
    29       Decl   : Gela.Grammars.Attribute_Declaration_Index;
     29      Decl   : Anagram.Grammars.Attribute_Declaration_Index;
    3030   end record;
    3131
     
    4343   type Context is tagged record
    4444      Factory    : AG_Tools.Visit_Generators.Factory_Access;
    45       Grammar   : Gela.Grammars.Grammar_Access;
     45      Grammar   : Anagram.Grammars.Grammar_Access;
    4646      Partition : Partition_Array_Access;
    4747      Part_Map  : Part_Map_Access;
  • trunk/ada-2012/tools/ag/ag_tools-element_generators.adb

    r416 r537  
    88package body AG_Tools.Element_Generators is
    99
    10    type NT_Map is array (Gela.Grammars.Non_Terminal_Index range <>)
     10   type NT_Map is array (Anagram.Grammars.Non_Terminal_Index range <>)
    1111     of Boolean;
    1212
    1313   procedure Write_Parts
    14      (G        : Gela.Grammars.Grammar_Access;
    15       Prod     : Gela.Grammars.Production;
     14     (G        : Anagram.Grammars.Grammar_Access;
     15      Prod     : Anagram.Grammars.Production;
    1616      Nodes_NT : in out Writers.Writer;
    1717      Withes   : in out Writers.Writer;
     
    1919
    2020   procedure Generate_Element
    21      (G  : Gela.Grammars.Grammar_Access;
    22       NT : Gela.Grammars.Non_Terminal);
     21     (G  : Anagram.Grammars.Grammar_Access;
     22      NT : Anagram.Grammars.Non_Terminal);
    2323
    2424   procedure Generate_Node
    25      (G  : Gela.Grammars.Grammar_Access;
    26       NT : Gela.Grammars.Non_Terminal);
    27 
    28    procedure Generate_Node_Factory (G  : Gela.Grammars.Grammar_Access);
     25     (G  : Anagram.Grammars.Grammar_Access;
     26      NT : Anagram.Grammars.Non_Terminal);
     27
     28   procedure Generate_Node_Factory (G  : Anagram.Grammars.Grammar_Access);
    2929
    3030   procedure Generate_Node_Sequence
    31      (NT : Gela.Grammars.Non_Terminal);
     31     (NT : Anagram.Grammars.Non_Terminal);
    3232
    3333   procedure Generate_Constructor
    34      (G    : Gela.Grammars.Grammar_Access;
    35       NT   : Gela.Grammars.Non_Terminal;
    36       Prod : Gela.Grammars.Production;
     34     (G    : Anagram.Grammars.Grammar_Access;
     35      NT   : Anagram.Grammars.Non_Terminal;
     36      Prod : Anagram.Grammars.Production;
    3737      Spec : in out AG_Tools.Writers.Writer;
    3838      Used : in out NT_Map);
    3939
    4040   procedure Generate_Sequence_Constructor
    41      (G    : Gela.Grammars.Grammar_Access;
    42       NT   : Gela.Grammars.Non_Terminal;
     41     (G    : Anagram.Grammars.Grammar_Access;
     42      NT   : Anagram.Grammars.Non_Terminal;
    4343      Spec : in out AG_Tools.Writers.Writer);
    4444
    4545   function Return_Type_Image
    46      (G    : Gela.Grammars.Grammar_Access;
    47       Part : Gela.Grammars.Part)
     46     (G    : Anagram.Grammars.Grammar_Access;
     47      Part : Anagram.Grammars.Part)
    4848         return League.Strings.Universal_String;
    4949
    5050   procedure Write_Attr_With
    51      (G      : Gela.Grammars.Grammar_Access;
    52       NT     : Gela.Grammars.Non_Terminal;
     51     (G      : Anagram.Grammars.Grammar_Access;
     52      NT     : Anagram.Grammars.Non_Terminal;
    5353      Output : in out AG_Tools.Writers.Writer;
    5454      Done   : in out League.String_Vectors.Universal_String_Vector);
    5555
    5656   procedure Write_Attr_Get
    57      (Decl   : Gela.Grammars.Attribute_Declaration;
     57     (Decl   : Anagram.Grammars.Attribute_Declaration;
    5858      Output : in out AG_Tools.Writers.Writer;
    5959      Name   : League.Strings.Universal_String;
     
    6161
    6262   procedure Write_Attr_Set
    63      (Decl   : Gela.Grammars.Attribute_Declaration;
     63     (Decl   : Anagram.Grammars.Attribute_Declaration;
    6464      Output : in out AG_Tools.Writers.Writer;
    6565      Name   : League.Strings.Universal_String;
     
    7171
    7272   procedure Generate_Constructor
    73      (G    : Gela.Grammars.Grammar_Access;
    74       NT   : Gela.Grammars.Non_Terminal;
    75       Prod : Gela.Grammars.Production;
     73     (G    : Anagram.Grammars.Grammar_Access;
     74      NT   : Anagram.Grammars.Non_Terminal;
     75      Prod : Anagram.Grammars.Production;
    7676      Spec : in out AG_Tools.Writers.Writer;
    7777      Used : in out NT_Map) is
     
    104104
    105105   procedure Generate_Element
    106      (G  : Gela.Grammars.Grammar_Access;
    107       NT : Gela.Grammars.Non_Terminal)
     106     (G  : Anagram.Grammars.Grammar_Access;
     107      NT : Anagram.Grammars.Non_Terminal)
    108108   is
    109109      use AG_Tools.Input;
     
    111111
    112112      procedure Write_Attr
    113         (NT    : Gela.Grammars.Non_Terminal;
     113        (NT    : Anagram.Grammars.Non_Terminal;
    114114         Attrs : in out AG_Tools.Writers.Writer);
    115115
     
    121121
    122122      procedure Write_Attr
    123         (NT    : Gela.Grammars.Non_Terminal;
     123        (NT    : Anagram.Grammars.Non_Terminal;
    124124         Attrs : in out AG_Tools.Writers.Writer) is
    125125      begin
     
    246246   -----------------------
    247247
    248    procedure Generate_Elements (G : Gela.Grammars.Grammar_Access) is
     248   procedure Generate_Elements (G : Anagram.Grammars.Grammar_Access) is
    249249   begin
    250250      for NT of G.Non_Terminal loop
     
    266266
    267267   procedure Generate_Factory
    268      (G : Gela.Grammars.Grammar_Access)
     268     (G : Anagram.Grammars.Grammar_Access)
    269269   is
    270270      Spec   : AG_Tools.Writers.Writer;
     
    330330
    331331   procedure Generate_Node
    332      (G  : Gela.Grammars.Grammar_Access;
    333       NT : Gela.Grammars.Non_Terminal)
     332     (G  : Anagram.Grammars.Grammar_Access;
     333      NT : Anagram.Grammars.Non_Terminal)
    334334   is
    335335      use type League.Strings.Universal_String;
    336       use type Gela.Grammars.Part_Count;
     336      use type Anagram.Grammars.Part_Count;
    337337
    338338      procedure Write_Attr
    339         (NT    : Gela.Grammars.Non_Terminal;
     339        (NT    : Anagram.Grammars.Non_Terminal;
    340340         Nodes : in out AG_Tools.Writers.Writer;
    341341         Impl  : in out AG_Tools.Writers.Writer;
     
    351351
    352352      procedure Write_Attr
    353         (NT    : Gela.Grammars.Non_Terminal;
     353        (NT    : Anagram.Grammars.Non_Terminal;
    354354         Nodes : in out AG_Tools.Writers.Writer;
    355355         Impl  : in out AG_Tools.Writers.Writer;
     
    360360         for A in NT.First_Attribute .. NT.Last_Attribute loop
    361361            declare
    362                Decl : Gela.Grammars.Attribute_Declaration renames
     362               Decl : Anagram.Grammars.Attribute_Declaration renames
    363363                 G.Declaration (A);
    364364            begin
     
    411411      Pkg    : constant League.Strings.Universal_String :=
    412412        "Gela.Elements." & Plural (NT.Name);
    413       Prod   : Gela.Grammars.Production renames G.Production (NT.First);
     413      Prod   : Anagram.Grammars.Production renames G.Production (NT.First);
    414414
    415415      Part_Type    : League.Strings.Universal_String;
     
    693693   --------------------------
    694694
    695    procedure Generate_Node_Factory (G  : Gela.Grammars.Grammar_Access) is
     695   procedure Generate_Node_Factory (G  : Anagram.Grammars.Grammar_Access) is
    696696      Spec   : AG_Tools.Writers.Writer;
    697697      Withes : AG_Tools.Writers.Writer;
     
    823823
    824824   procedure Generate_Node_Sequence
    825      (NT : Gela.Grammars.Non_Terminal)
     825     (NT : Anagram.Grammars.Non_Terminal)
    826826   is
    827827      Nodes  : AG_Tools.Writers.Writer;
     
    856856
    857857   procedure Generate_Sequence_Constructor
    858      (G    : Gela.Grammars.Grammar_Access;
    859       NT   : Gela.Grammars.Non_Terminal;
     858     (G    : Anagram.Grammars.Grammar_Access;
     859      NT   : Anagram.Grammars.Non_Terminal;
    860860      Spec : in out AG_Tools.Writers.Writer) is
    861861   begin
     
    874874
    875875   function Return_Type_Image
    876      (G    : Gela.Grammars.Grammar_Access;
    877       Part : Gela.Grammars.Part)
     876     (G    : Anagram.Grammars.Grammar_Access;
     877      Part : Anagram.Grammars.Part)
    878878         return League.Strings.Universal_String
    879879   is
     
    896896
    897897   procedure Write_Attr_With
    898      (G     : Gela.Grammars.Grammar_Access;
    899       NT     : Gela.Grammars.Non_Terminal;
     898     (G     : Anagram.Grammars.Grammar_Access;
     899      NT     : Anagram.Grammars.Non_Terminal;
    900900      Output : in out AG_Tools.Writers.Writer;
    901901      Done   : in out League.String_Vectors.Universal_String_Vector)
     
    920920
    921921   procedure Write_Attr_Get
    922      (Decl   : Gela.Grammars.Attribute_Declaration;
     922     (Decl   : Anagram.Grammars.Attribute_Declaration;
    923923      Output : in out AG_Tools.Writers.Writer;
    924924      Name   : League.Strings.Universal_String;
     
    943943
    944944   procedure Write_Attr_Set
    945      (Decl   : Gela.Grammars.Attribute_Declaration;
     945     (Decl   : Anagram.Grammars.Attribute_Declaration;
    946946      Output : in out AG_Tools.Writers.Writer;
    947947      Name   : League.Strings.Universal_String;
     
    967967
    968968   procedure Write_Parts
    969      (G        : Gela.Grammars.Grammar_Access;
    970       Prod     : Gela.Grammars.Production;
     969     (G        : Anagram.Grammars.Grammar_Access;
     970      Prod     : Anagram.Grammars.Production;
    971971      Nodes_NT : in out Writers.Writer;
    972972      Withes   : in out Writers.Writer;
  • trunk/ada-2012/tools/ag/ag_tools-element_generators.ads

    r415 r537  
    22
    33   procedure Generate_Elements
    4      (G : Gela.Grammars.Grammar_Access);
     4     (G : Anagram.Grammars.Grammar_Access);
    55
    66   procedure Generate_Factory
    7      (G : Gela.Grammars.Grammar_Access);
     7     (G : Anagram.Grammars.Grammar_Access);
    88
    99end AG_Tools.Element_Generators;
  • trunk/ada-2012/tools/ag/ag_tools-generator_factories.adb

    r415 r537  
    2121   overriding function Get
    2222     (Self : access Factory;
    23       NT   : Gela.Grammars.Non_Terminal)
     23      NT   : Anagram.Grammars.Non_Terminal)
    2424      return AG_Tools.Visit_Generators.NT_Generator_Access
    2525   is
     
    4040   overriding function Get
    4141     (Self : access Factory;
    42       Part : Gela.Grammars.Part)
     42      Part : Anagram.Grammars.Part)
    4343      return AG_Tools.Visit_Generators.Part_Generator_Access
    4444   is
    4545      use type League.Strings.Universal_String;
    46       G    : Gela.Grammars.Grammar renames Self.Context.Grammar.all;
     46      G    : Anagram.Grammars.Grammar renames Self.Context.Grammar.all;
    4747   begin
    4848      if Part.Name = Tail then
     
    6565   overriding function Get
    6666     (Self : access Factory;
    67       Attr : Gela.Grammars.Attribute;
    68       NT   : Gela.Grammars.Non_Terminal)
     67      Attr : Anagram.Grammars.Attribute;
     68      NT   : Anagram.Grammars.Non_Terminal)
    6969      return AG_Tools.Visit_Generators.Generator_Access
    7070   is
  • trunk/ada-2012/tools/ag/ag_tools-generator_factories.ads

    r415 r537  
    2020   overriding function Get
    2121     (Self : access Factory;
    22       NT   : Gela.Grammars.Non_Terminal)
     22      NT   : Anagram.Grammars.Non_Terminal)
    2323      return AG_Tools.Visit_Generators.NT_Generator_Access;
    2424
    2525   overriding function Get
    2626     (Self : access Factory;
    27       Part : Gela.Grammars.Part)
     27      Part : Anagram.Grammars.Part)
    2828      return AG_Tools.Visit_Generators.Part_Generator_Access;
    2929
    3030   overriding function Get
    3131     (Self : access Factory;
    32       Attr : Gela.Grammars.Attribute;
    33       NT   : Gela.Grammars.Non_Terminal)
     32      Attr : Anagram.Grammars.Attribute;
     33      NT   : Anagram.Grammars.Non_Terminal)
    3434      return AG_Tools.Visit_Generators.Generator_Access;
    3535
  • trunk/ada-2012/tools/ag/ag_tools-input.adb

    r529 r537  
    1414with League.Strings.Hash;
    1515
    16 with Gela.Grammars.Reader;
    17 with Gela.Grammars.Constructors;
     16with Anagram.Grammars.Reader;
     17with Anagram.Grammars.Constructors;
    1818
    1919with AG_Tools.Check_Ordered; use AG_Tools.Check_Ordered;
     
    2222
    2323   type NT_List is array
    24      (Gela.Grammars.Non_Terminal_Index range <>) of Boolean;
     24     (Anagram.Grammars.Non_Terminal_Index range <>) of Boolean;
    2525
    2626   type NT_List_Access is access all NT_List;
    2727
    2828   type NT_NT_Map is array
    29      (Gela.Grammars.Non_Terminal_Index range <>,
    30       Gela.Grammars.Non_Terminal_Index range <>) of Boolean;
     29     (Anagram.Grammars.Non_Terminal_Index range <>,
     30      Anagram.Grammars.Non_Terminal_Index range <>) of Boolean;
    3131
    3232   type NT_NT_Map_Access is access all NT_NT_Map;
    3333
    3434   function Macro_Reference
    35      (G    : Gela.Grammars.Grammar;
    36       Prod : Gela.Grammars.Production)
    37       return Gela.Grammars.Non_Terminal_Count;
     35     (G    : Anagram.Grammars.Grammar;
     36      Prod : Anagram.Grammars.Production)
     37      return Anagram.Grammars.Non_Terminal_Count;
    3838   --  If Prod is just reference to another NT, return NT.Index.
    3939   --  Return 0 otherwise.
    4040
    4141   function List_Reference
    42      (G    : Gela.Grammars.Grammar;
    43       Part : Gela.Grammars.Part)
    44       return Gela.Grammars.Non_Terminal_Count;
     42     (G    : Anagram.Grammars.Grammar;
     43      Part : Anagram.Grammars.Part)
     44      return Anagram.Grammars.Non_Terminal_Count;
    4545   --  If Part is reference to list, return NT.Index of the list
    4646   --  Return 0 otherwise
    4747
    4848   procedure Look_For_List
    49      (G    : Gela.Grammars.Grammar;
    50       Prod : Gela.Grammars.Production);
     49     (G    : Anagram.Grammars.Grammar;
     50      Prod : Anagram.Grammars.Production);
    5151   --  If any port of Prod is reference to list of some NT then
    5252   --  mark With_List (NT) as True
    5353
    5454   procedure Copy
    55      (G : Gela.Grammars.Grammar;
    56       V : in out Gela.Grammars.Constructors.Constructor;
     55     (G : Anagram.Grammars.Grammar;
     56      V : in out Anagram.Grammars.Constructors.Constructor;
    5757      Is_Concrete : NT_List);
    5858
    5959   procedure Copy_Attr
    60      (G      : Gela.Grammars.Grammar;
    61       V      : in out Gela.Grammars.Constructors.Constructor;
    62       Child  : Gela.Grammars.Non_Terminal_Index;
    63       Parent : Gela.Grammars.Non_Terminal_Index;
     60     (G      : Anagram.Grammars.Grammar;
     61      V      : in out Anagram.Grammars.Constructors.Constructor;
     62      Child  : Anagram.Grammars.Non_Terminal_Index;
     63      Parent : Anagram.Grammars.Non_Terminal_Index;
    6464      Done   : in out League.String_Vectors.Universal_String_Vector);
    6565
    6666   procedure Copy_Productions
    67      (G : Gela.Grammars.Grammar;
    68       V : in out Gela.Grammars.Constructors.Constructor;
    69       From : Gela.Grammars.Production_Index;
    70       To   : Gela.Grammars.Production_Count;
    71       PL : in out Gela.Grammars.Constructors.Production_List);
     67     (G : Anagram.Grammars.Grammar;
     68      V : in out Anagram.Grammars.Constructors.Constructor;
     69      From : Anagram.Grammars.Production_Index;
     70      To   : Anagram.Grammars.Production_Count;
     71      PL : in out Anagram.Grammars.Constructors.Production_List);
    7272
    7373   procedure Add_Option
    74      (G    : Gela.Grammars.Grammar;
    75       Prod : Gela.Grammars.Production;
    76       Part : Gela.Grammars.Part);
     74     (G    : Anagram.Grammars.Grammar;
     75      Prod : Anagram.Grammars.Production;
     76      Part : Anagram.Grammars.Part);
    7777   --  Remember Prod.Part as option
    7878
     
    8383      "="                 => League.Strings."=");
    8484
    85    G            : Gela.Grammars.Grammar_Access;
     85   G            : Anagram.Grammars.Grammar_Access;
    8686   Concrete     : NT_List_Access;
    8787   With_List    : NT_List_Access;
     
    9494
    9595   procedure Add_Option
    96      (G    : Gela.Grammars.Grammar;
    97       Prod : Gela.Grammars.Production;
    98       Part : Gela.Grammars.Part)
     96     (G    : Anagram.Grammars.Grammar;
     97      Prod : Anagram.Grammars.Production;
     98      Part : Anagram.Grammars.Part)
    9999   is
    100100      use type League.Strings.Universal_String;
    101       NT   : Gela.Grammars.Non_Terminal renames G.Non_Terminal (Prod.Parent);
     101      NT   : Anagram.Grammars.Non_Terminal renames
     102        G.Non_Terminal (Prod.Parent);
    102103      Name : constant League.Strings.Universal_String :=
    103104        NT.Name & " " & Prod.Name & " " & Part.Name;
     
    111112
    112113   procedure Copy
    113      (G : Gela.Grammars.Grammar;
    114       V : in out Gela.Grammars.Constructors.Constructor;
     114     (G : Anagram.Grammars.Grammar;
     115      V : in out Anagram.Grammars.Constructors.Constructor;
    115116      Is_Concrete : NT_List) is
    116117   begin
    117118      for J in G.Terminal'Range loop
    118119         declare
    119             T : Gela.Grammars.Terminal renames G.Terminal (J);
     120            T : Anagram.Grammars.Terminal renames G.Terminal (J);
    120121         begin
    121122            V.Create_Terminal (T.Image, T.Precedence);
     
    132133      for J in G.Non_Terminal'Range loop
    133134         declare
    134             N  : Gela.Grammars.Non_Terminal renames G.Non_Terminal (J);
    135             PL : Gela.Grammars.Constructors.Production_List :=
     135            N  : Anagram.Grammars.Non_Terminal renames G.Non_Terminal (J);
     136            PL : Anagram.Grammars.Constructors.Production_List :=
    136137              V.Create_Production_List;
    137138         begin
     
    154155            for K in N.First .. N.Last loop
    155156               declare
    156                   S : Gela.Grammars.Production renames G.Production (K);
     157                  S : Anagram.Grammars.Production renames G.Production (K);
    157158               begin
    158159                  for Y in S.First_Rule .. S.Last_Rule loop
    159160                     declare
    160                         R : Gela.Grammars.Rule renames G.Rule (Y);
     161                        R : Anagram.Grammars.Rule renames G.Rule (Y);
    161162                     begin
    162163                        V.Create_Rule (N.Name, S.Name, R.Text);
     
    178179
    179180   procedure Copy_Attr
    180      (G      : Gela.Grammars.Grammar;
    181       V      : in out Gela.Grammars.Constructors.Constructor;
    182       Child  : Gela.Grammars.Non_Terminal_Index;
    183       Parent : Gela.Grammars.Non_Terminal_Index;
     181     (G      : Anagram.Grammars.Grammar;
     182      V      : in out Anagram.Grammars.Constructors.Constructor;
     183      Child  : Anagram.Grammars.Non_Terminal_Index;
     184      Parent : Anagram.Grammars.Non_Terminal_Index;
    184185      Done   : in out League.String_Vectors.Universal_String_Vector)
    185186   is
    186       X : Gela.Grammars.Non_Terminal renames G.Non_Terminal (Child);
    187       Y : Gela.Grammars.Non_Terminal renames G.Non_Terminal (Parent);
     187      X : Anagram.Grammars.Non_Terminal renames G.Non_Terminal (Child);
     188      Y : Anagram.Grammars.Non_Terminal renames G.Non_Terminal (Parent);
    188189   begin
    189190      for K in Y.First_Attribute .. Y.Last_Attribute loop
    190191         declare
    191             YA : Gela.Grammars.Attribute_Declaration renames
     192            YA : Anagram.Grammars.Attribute_Declaration renames
    192193              G.Declaration (K);
    193194         begin
     
    202203                  use type League.Strings.Universal_String;
    203204
    204                   XA : Gela.Grammars.Attribute_Declaration renames
     205                  XA : Anagram.Grammars.Attribute_Declaration renames
    205206                    G.Declaration (J);
    206207                  Text : League.Strings.Universal_String;
     
    231232
    232233   procedure Copy_Productions
    233      (G : Gela.Grammars.Grammar;
    234       V : in out Gela.Grammars.Constructors.Constructor;
    235       From : Gela.Grammars.Production_Index;
    236       To   : Gela.Grammars.Production_Count;
    237       PL : in out Gela.Grammars.Constructors.Production_List)
     234     (G : Anagram.Grammars.Grammar;
     235      V : in out Anagram.Grammars.Constructors.Constructor;
     236      From : Anagram.Grammars.Production_Index;
     237      To   : Anagram.Grammars.Production_Count;
     238      PL : in out Anagram.Grammars.Constructors.Production_List)
    238239   is
    239240   begin
    240241      for K in From .. To loop
    241242         declare
    242             S : Gela.Grammars.Production renames G.Production (K);
    243             P : Gela.Grammars.Constructors.Production :=
     243            S : Anagram.Grammars.Production renames G.Production (K);
     244            P : Anagram.Grammars.Constructors.Production :=
    244245              V.Create_Production (S.Name, S.Precedence);
    245246         begin
    246247            for X in S.First .. S.Last loop
    247248               declare
    248                   R : Gela.Grammars.Part renames G.Part (X);
     249                  R : Anagram.Grammars.Part renames G.Part (X);
    249250               begin
    250251                  if R.Is_Terminal_Reference then
     
    264265                     --  nested items
    265266                     declare
    266                         Nested_Production : Gela.Grammars.Production renames
     267                        Nested_Production : Anagram.Grammars.Production renames
    267268                          G.Production (R.First);
    268                         Nested_Part : Gela.Grammars.Part renames
     269                        Nested_Part : Anagram.Grammars.Part renames
    269270                          G.Part (Nested_Production.First);
    270271                     begin
     
    303304   -------------
    304305
    305    function Grammar return Gela.Grammars.Grammar_Access is
     306   function Grammar return Anagram.Grammars.Grammar_Access is
    306307   begin
    307308      return G;
     
    312313   --------------
    313314
    314    function Has_List (NT : Gela.Grammars.Non_Terminal_Index) return Boolean is
     315   function Has_List
     316     (NT : Anagram.Grammars.Non_Terminal_Index) return Boolean is
    315317   begin
    316318      return With_List (NT);
     
    321323
    322324   function Implement
    323      (X, Y : Gela.Grammars.Non_Terminal_Index) return Boolean is
     325     (X, Y : Anagram.Grammars.Non_Terminal_Index) return Boolean is
    324326   begin
    325327      return Is_Implement (X, Y);
     
    331333
    332334   procedure Initialize (File_Name : String) is
    333       use type Gela.Grammars.Production_Count;
    334       use type Gela.Grammars.Non_Terminal_Count;
    335 
    336       F : constant Gela.Grammars.Grammar :=
    337         Gela.Grammars.Reader.Read (File_Name, Tail_List => True);
     335      use type Anagram.Grammars.Production_Count;
     336      use type Anagram.Grammars.Non_Terminal_Count;
     337
     338      F : constant Anagram.Grammars.Grammar :=
     339        Anagram.Grammars.Reader.Read (File_Name, Tail_List => True);
    338340   begin
    339341      Concrete := new NT_List'(F.Non_Terminal'Range => False);
     
    361363            for Prod of F.Production (NT.First .. NT.Last) loop
    362364               declare
    363                   Ref : constant Gela.Grammars.Non_Terminal_Count :=
     365                  Ref : constant Anagram.Grammars.Non_Terminal_Count :=
    364366                    Macro_Reference (F, Prod);
    365367               begin
     
    374376
    375377      declare
    376          V : Gela.Grammars.Constructors.Constructor;
     378         V : Anagram.Grammars.Constructors.Constructor;
    377379      begin
    378380         Copy (F, V, Concrete.all);
     
    390392         end loop;
    391393
    392          G := new Gela.Grammars.Grammar'(V.Complete);
     394         G := new Anagram.Grammars.Grammar'(V.Complete);
    393395      end;
    394396
     
    402404
    403405   function Is_Concrete
    404      (NT : Gela.Grammars.Non_Terminal_Index) return Boolean is
     406     (NT : Anagram.Grammars.Non_Terminal_Index) return Boolean is
    405407   begin
    406408      return Concrete (NT);
     
    412414
    413415   function Is_Option
    414      (G    : Gela.Grammars.Grammar;
    415       Part : Gela.Grammars.Part) return Boolean
     416     (G    : Anagram.Grammars.Grammar;
     417      Part : Anagram.Grammars.Part) return Boolean
    416418   is
    417419      use type League.Strings.Universal_String;
    418       Prod : Gela.Grammars.Production renames G.Production (Part.Parent);
    419       NT   : Gela.Grammars.Non_Terminal renames G.Non_Terminal (Prod.Parent);
     420      Prod : Anagram.Grammars.Production renames G.Production (Part.Parent);
     421      NT   : Anagram.Grammars.Non_Terminal renames
     422        G.Non_Terminal (Prod.Parent);
    420423      Name : constant League.Strings.Universal_String :=
    421424        NT.Name & " " & Prod.Name & " " & Part.Name;
     
    429432
    430433   function List_Reference
    431      (G    : Gela.Grammars.Grammar;
    432       Part : Gela.Grammars.Part)
    433       return Gela.Grammars.Non_Terminal_Count is
     434     (G    : Anagram.Grammars.Grammar;
     435      Part : Anagram.Grammars.Part)
     436      return Anagram.Grammars.Non_Terminal_Count is
    434437   begin
    435438      if Part.Is_List_Reference then
    436439         declare
    437             NT   : Gela.Grammars.Non_Terminal renames
     440            NT   : Anagram.Grammars.Non_Terminal renames
    438441              G.Non_Terminal (Part.Denote);
    439442         begin
     
    450453
    451454   procedure Look_For_List
    452      (G    : Gela.Grammars.Grammar;
    453       Prod : Gela.Grammars.Production)
     455     (G    : Anagram.Grammars.Grammar;
     456      Prod : Anagram.Grammars.Production)
    454457   is
    455       use type Gela.Grammars.Non_Terminal_Count;
    456       List : Gela.Grammars.Non_Terminal_Count;
     458      use type Anagram.Grammars.Non_Terminal_Count;
     459      List : Anagram.Grammars.Non_Terminal_Count;
    457460   begin
    458461      for Part of G.Part (Prod.First .. Prod.Last) loop
     
    469472
    470473   function Macro_Reference
    471      (G    : Gela.Grammars.Grammar;
    472       Prod : Gela.Grammars.Production)
    473       return Gela.Grammars.Non_Terminal_Count
     474     (G    : Anagram.Grammars.Grammar;
     475      Prod : Anagram.Grammars.Production)
     476      return Anagram.Grammars.Non_Terminal_Count
    474477   is
    475478      use type League.Strings.Universal_String;
    476       use type Gela.Grammars.Part_Count;
     479      use type Anagram.Grammars.Part_Count;
    477480   begin
    478481      if Prod.First /= Prod.Last then
     
    481484
    482485      declare
    483          Part : Gela.Grammars.Part renames G.Part (Prod.First);
     486         Part : Anagram.Grammars.Part renames G.Part (Prod.First);
    484487      begin
    485488         if not Part.Is_Non_Terminal_Reference then
     
    498501
    499502   function Macro_Reference
    500      (Prod : Gela.Grammars.Production)
    501       return Gela.Grammars.Non_Terminal_Count is
     503     (Prod : Anagram.Grammars.Production)
     504      return Anagram.Grammars.Non_Terminal_Count is
    502505   begin
    503506      return Macro_Reference (G.all, Prod);
  • trunk/ada-2012/tools/ag/ag_tools-input.ads

    r415 r537  
    88------------------------------------------------------------------------------
    99
    10 with Gela.Grammars;
     10with Anagram.Grammars;
    1111
    1212package AG_Tools.Input is
     
    2424   --  * create attribution rules for abstract productions as trivial copy-rule
    2525
    26    function Grammar return Gela.Grammars.Grammar_Access;
     26   function Grammar return Anagram.Grammars.Grammar_Access;
    2727
    28    function Is_Concrete (NT : Gela.Grammars.Non_Terminal_Index) return Boolean;
     28   function Is_Concrete
     29     (NT : Anagram.Grammars.Non_Terminal_Index) return Boolean;
    2930   --  Return true if NT has production with several parts, in other words
    3031   --  there is production in form NT ::= child_1 child_2 ..;
    3132   --  Such NT has just single production
    3233
    33    function Implement (X, Y : Gela.Grammars.Non_Terminal_Index) return Boolean;
     34   function Implement
     35     (X, Y : Anagram.Grammars.Non_Terminal_Index) return Boolean;
    3436   --  If Implement (X, Y) then X implement Y, in other words there is
    3537   --  production  Y := X | ..;
    3638
    3739   function Macro_Reference
    38      (Prod : Gela.Grammars.Production)
    39       return Gela.Grammars.Non_Terminal_Count;
     40     (Prod : Anagram.Grammars.Production)
     41      return Anagram.Grammars.Non_Terminal_Count;
    4042   --  If Prod is just reference to another NT, return NT.Index.
    4143   --  Return 0 otherwise.
    4244
    43    function Has_List (NT : Gela.Grammars.Non_Terminal_Index) return Boolean;
     45   function Has_List (NT : Anagram.Grammars.Non_Terminal_Index) return Boolean;
    4446   --  If there are references to {NT} then Has_List (NT) = True
    4547
    4648   function Is_Option
    47      (G    : Gela.Grammars.Grammar;
    48       Part : Gela.Grammars.Part) return Boolean;
     49     (G    : Anagram.Grammars.Grammar;
     50      Part : Anagram.Grammars.Part) return Boolean;
    4951   --  Return True if Part was option in original grammar
    5052
  • trunk/ada-2012/tools/ag/ag_tools-nt_generators.adb

    r415 r537  
    1818   procedure Write_Declaration
    1919     (Context : AG_Tools.Contexts.Context_Access;
    20       NT      : Gela.Grammars.Non_Terminal;
     20      NT      : Anagram.Grammars.Non_Terminal;
    2121      Pass    : Positive);
    2222
    2323   procedure Generate_Rule
    24      (T    : Gela.Grammars.Rule_Templates.Rule_Template;
    25       NT   : Gela.Grammars.Non_Terminal;
     24     (T    : Anagram.Grammars.Rule_Templates.Rule_Template;
     25      NT   : Anagram.Grammars.Non_Terminal;
    2626      Impl : in out AG_Tools.Writers.Writer);
    2727   --  Output text of rule to Impl
     
    2929   procedure Write_Rules
    3030     (Context : AG_Tools.Contexts.Context_Access;
    31       NT      : Gela.Grammars.Non_Terminal;
    32       Prod    : Gela.Grammars.Production_Index;
     31      NT      : Anagram.Grammars.Non_Terminal;
     32      Prod    : Anagram.Grammars.Production_Index;
    3333      Pass    : Positive;
    34       Each    : in out Gela.Grammars.Ordered.Order_Maps.Cursor);
     34      Each    : in out Anagram.Grammars.Ordered.Order_Maps.Cursor);
    3535
    3636   This : constant League.Strings.Universal_String :=
     
    3838
    3939   procedure Generate_Rule
    40      (T    : Gela.Grammars.Rule_Templates.Rule_Template;
    41       NT   : Gela.Grammars.Non_Terminal;
     40     (T    : Anagram.Grammars.Rule_Templates.Rule_Template;
     41      NT   : Anagram.Grammars.Non_Terminal;
    4242      Impl : in out AG_Tools.Writers.Writer)
    4343   is
    44       use Gela.Grammars;
     44      use Anagram.Grammars;
    4545
    4646      Value  : League.Strings.Universal_String;
     
    6969   overriding procedure Make_Get
    7070     (Self      : access Generator;
    71       Attribute : Gela.Grammars.Attribute;
    72       Template  : Gela.Grammars.Rule_Templates.Rule_Template)
     71      Attribute : Anagram.Grammars.Attribute;
     72      Template  : Anagram.Grammars.Rule_Templates.Rule_Template)
    7373   is
    7474      pragma Unreferenced (Template);
    75       G      : Gela.Grammars.Grammar renames Self.Context.Grammar.all;
     75      G      : Anagram.Grammars.Grammar renames Self.Context.Grammar.all;
    7676      Code   : AG_Tools.Writers.Writer renames Self.Context.Code;
    77       D      : Gela.Grammars.Attribute_Declaration renames
     77      D      : Anagram.Grammars.Attribute_Declaration renames
    7878        G.Declaration (Attribute.Declaration);
    7979   begin
     
    9393   overriding procedure Make_Get
    9494     (Self      : access List_Generator;
    95       Attribute : Gela.Grammars.Attribute;
    96       Template  : Gela.Grammars.Rule_Templates.Rule_Template)
     95      Attribute : Anagram.Grammars.Attribute;
     96      Template  : Anagram.Grammars.Rule_Templates.Rule_Template)
    9797   is
    9898      pragma Unreferenced (Self);
     
    109109     (Self      : access Generator;
    110110      Origin    : League.Strings.Universal_String;
    111       Attribute : Gela.Grammars.Attribute_Declaration)
     111      Attribute : Anagram.Grammars.Attribute_Declaration)
    112112   is
    113113      Impl : AG_Tools.Writers.Writer renames Self.Context.Impl;
     
    137137     (Self      : access List_Generator;
    138138      Origin    : League.Strings.Universal_String;
    139       Attribute : Gela.Grammars.Attribute_Declaration)
     139      Attribute : Anagram.Grammars.Attribute_Declaration)
    140140   is
    141141      pragma Unreferenced (Self);
     
    151151   overriding procedure Make_Procedure
    152152     (Self  : access Generator;
    153       Order : Gela.Grammars.Ordered.Order_Maps.Map;
    154       NT    : Gela.Grammars.Non_Terminal;
     153      Order : Anagram.Grammars.Ordered.Order_Maps.Map;
     154      NT    : Anagram.Grammars.Non_Terminal;
    155155      Pass  : Positive)
    156156   is
    157       Pos : Gela.Grammars.Ordered.Order_Maps.Cursor :=
     157      Pos : Anagram.Grammars.Ordered.Order_Maps.Cursor :=
    158158        Order.Ceiling ((NT.First, Pass, Step => 1));
    159159
     
    196196   overriding procedure Make_Procedure
    197197     (Self  : access List_Generator;
    198       Order : Gela.Grammars.Ordered.Order_Maps.Map;
    199       NT    : Gela.Grammars.Non_Terminal;
     198      Order : Anagram.Grammars.Ordered.Order_Maps.Map;
     199      NT    : Anagram.Grammars.Non_Terminal;
    200200      Pass  : Positive)
    201201   is
    202       Pos : Gela.Grammars.Ordered.Order_Maps.Cursor :=
     202      Pos : Anagram.Grammars.Ordered.Order_Maps.Cursor :=
    203203        Order.Ceiling ((NT.First, Pass, Step => 1));
    204204
    205       Prod : Gela.Grammars.Production renames
     205      Prod : Anagram.Grammars.Production renames
    206206        Self.Context.Grammar.Production (NT.First);
    207207
    208       G  : Gela.Grammars.Grammar renames Self.Context.Grammar.all;
     208      G  : Anagram.Grammars.Grammar renames Self.Context.Grammar.all;
    209209      RT : constant League.Strings.Universal_String := Return_Type (G, NT);
    210       Parts   : Gela.Grammars.Ordered.Partition_Array renames
     210      Parts   : Anagram.Grammars.Ordered.Partition_Array renames
    211211        Self.Context.Partition (NT.First_Attribute .. NT.Last_Attribute);
    212212      Spec    : AG_Tools.Writers.Writer renames Self.Context.Spec;
     
    214214      Code    : AG_Tools.Writers.Writer renames Self.Context.Code;
    215215      Piece   : AG_Tools.Writers.Writer;
    216       Item_NT : Gela.Grammars.Non_Terminal renames G.Non_Terminal
     216      Item_NT : Anagram.Grammars.Non_Terminal renames G.Non_Terminal
    217217        (List_Item (G, NT));
    218218      Item : constant League.Strings.Universal_String :=
     
    227227
    228228      for J in NT.First_Attribute .. NT.Last_Attribute loop
    229          if Gela.Grammars.Ordered.To_Pass (Parts, J) = Pass then
     229         if Anagram.Grammars.Ordered.To_Pass (Parts, J) = Pass then
    230230            Spec.P (";", Impl);
    231231            Spec.N ("      ", Impl);
     
    304304
    305305      for J in NT.First_Attribute .. NT.Last_Attribute loop
    306          if Gela.Grammars.Ordered.To_Pass (Parts, J) = Pass then
     306         if Anagram.Grammars.Ordered.To_Pass (Parts, J) = Pass then
    307307            Impl.N (", ");
    308308            Impl.N (This);
     
    327327   overriding procedure Make_Procedure
    328328     (Self  : access Abstract_Generator;
    329       Order : Gela.Grammars.Ordered.Order_Maps.Map;
    330       NT    : Gela.Grammars.Non_Terminal;
     329      Order : Anagram.Grammars.Ordered.Order_Maps.Map;
     330      NT    : Anagram.Grammars.Non_Terminal;
    331331      Pass  : Positive)
    332332   is
    333       G : Gela.Grammars.Grammar renames Self.Context.Grammar.all;
     333      G : Anagram.Grammars.Grammar renames Self.Context.Grammar.all;
    334334
    335335      type Pass_Range is record
     
    342342
    343343      procedure Find
    344         (NT     : Gela.Grammars.Non_Terminal;
     344        (NT     : Anagram.Grammars.Non_Terminal;
    345345         Pass   : Positive;
    346346         Result : in out Pass_Array);
     
    367367
    368368      procedure Find
    369         (NT     : Gela.Grammars.Non_Terminal;
     369        (NT     : Anagram.Grammars.Non_Terminal;
    370370         Pass   : Positive;
    371371         Result : in out Pass_Array) is
     
    373373         for J in NT.First .. NT.Last loop
    374374            declare
    375                use Gela.Grammars.Ordered.Order_Maps;
    376                use type Gela.Grammars.Production_Index;
     375               use Anagram.Grammars.Ordered.Order_Maps;
     376               use type Anagram.Grammars.Production_Index;
    377377               Pos   : Cursor := Order.Ceiling ((J, Pass, Step => 1));
    378                Value : Gela.Grammars.Ordered.Action;
    379                Go    : Gela.Grammars.Non_Terminal_Index;
     378               Value : Anagram.Grammars.Ordered.Action;
     379               Go    : Anagram.Grammars.Non_Terminal_Index;
    380380            begin
    381381               while Has_Element (Pos) and then
     
    386386
    387387                  case Value.Kind is
    388                      when Gela.Grammars.Ordered.Descent =>
     388                     when Anagram.Grammars.Ordered.Descent =>
    389389                        Go := G.Part (Value.Part).Denote;
    390390
     
    394394                           Find (G.Non_Terminal (Go), Value.Pass, Result);
    395395                        end if;
    396                      when Gela.Grammars.Ordered.Evaluate_Rule =>
     396                     when Anagram.Grammars.Ordered.Evaluate_Rule =>
    397397                        null;
    398398                  end case;
     
    477477   overriding procedure Make_Set
    478478     (Self      : access Generator;
    479       Attribute : Gela.Grammars.Attribute)
    480    is
    481       G      : Gela.Grammars.Grammar renames Self.Context.Grammar.all;
     479      Attribute : Anagram.Grammars.Attribute)
     480   is
     481      G      : Anagram.Grammars.Grammar renames Self.Context.Grammar.all;
    482482      Code   : AG_Tools.Writers.Writer renames Self.Context.Code;
    483       D      : Gela.Grammars.Attribute_Declaration renames
     483      D      : Anagram.Grammars.Attribute_Declaration renames
    484484        G.Declaration (Attribute.Declaration);
    485485   begin
     
    500500   overriding procedure Make_Set
    501501     (Self      : access List_Generator;
    502       Attribute : Gela.Grammars.Attribute)
     502      Attribute : Anagram.Grammars.Attribute)
    503503   is
    504504      pragma Unreferenced (Self);
     
    514514   procedure Write_Declaration
    515515     (Context : AG_Tools.Contexts.Context_Access;
    516       NT      : Gela.Grammars.Non_Terminal;
     516      NT      : Anagram.Grammars.Non_Terminal;
    517517      Pass    : Positive)
    518518   is
     
    544544   procedure Write_Rules
    545545     (Context : AG_Tools.Contexts.Context_Access;
    546       NT      : Gela.Grammars.Non_Terminal;
    547       Prod    : Gela.Grammars.Production_Index;
     546      NT      : Anagram.Grammars.Non_Terminal;
     547      Prod    : Anagram.Grammars.Production_Index;
    548548      Pass    : Positive;
    549       Each    : in out Gela.Grammars.Ordered.Order_Maps.Cursor)
    550    is
    551       use Gela.Grammars;
    552       use Gela.Grammars.Ordered.Order_Maps;
    553       G       : Gela.Grammars.Grammar renames Context.Grammar.all;
     549      Each    : in out Anagram.Grammars.Ordered.Order_Maps.Cursor)
     550   is
     551      use Anagram.Grammars;
     552      use Anagram.Grammars.Ordered.Order_Maps;
     553      G       : Anagram.Grammars.Grammar renames Context.Grammar.all;
    554554   begin
    555555      while Has_Element (Each)
     
    559559
    560560         case Element (Each).Kind is
    561             when Gela.Grammars.Ordered.Evaluate_Rule =>
     561            when Anagram.Grammars.Ordered.Evaluate_Rule =>
    562562               declare
    563563                  Gen    : AG_Tools.Visit_Generators.Generator_Access;
     
    579579                  Gen.Make_Set (Result);
    580580               end;
    581             when Gela.Grammars.Ordered.Descent =>
     581            when Anagram.Grammars.Ordered.Descent =>
    582582               declare
    583583                  Gen : AG_Tools.Visit_Generators.Part_Generator_Access;
  • trunk/ada-2012/tools/ag/ag_tools-nt_generators.ads

    r415 r537  
    88------------------------------------------------------------------------------
    99
    10 with Gela.Grammars.Ordered;
     10with Anagram.Grammars.Ordered;
    1111
    1212with AG_Tools.Contexts;
    1313with AG_Tools.Visit_Generators;
    14 with Gela.Grammars.Rule_Templates;
     14with Anagram.Grammars.Rule_Templates;
    1515
    1616package AG_Tools.NT_Generators is
     
    2121   overriding procedure Make_Procedure
    2222     (Self  : access Generator;
    23       Order : Gela.Grammars.Ordered.Order_Maps.Map;
    24       NT    : Gela.Grammars.Non_Terminal;
     23      Order : Anagram.Grammars.Ordered.Order_Maps.Map;
     24      NT    : Anagram.Grammars.Non_Terminal;
    2525      Pass  : Positive);
    2626
     
    2828     (Self      : access Generator;
    2929      Origin    : League.Strings.Universal_String;
    30       Attribute : Gela.Grammars.Attribute_Declaration);
     30      Attribute : Anagram.Grammars.Attribute_Declaration);
    3131
    3232   overriding procedure Make_Get
    3333     (Self      : access Generator;
    34       Attribute : Gela.Grammars.Attribute;
    35       Template  : Gela.Grammars.Rule_Templates.Rule_Template);
     34      Attribute : Anagram.Grammars.Attribute;
     35      Template  : Anagram.Grammars.Rule_Templates.Rule_Template);
    3636
    3737   overriding procedure Make_Set
    3838     (Self      : access Generator;
    39       Attribute : Gela.Grammars.Attribute);
     39      Attribute : Anagram.Grammars.Attribute);
    4040
    4141   type List_Generator (Context : AG_Tools.Contexts.Context_Access)
     
    4444   overriding procedure Make_Procedure
    4545     (Self  : access List_Generator;
    46       Order : Gela.Grammars.Ordered.Order_Maps.Map;
    47       NT    : Gela.Grammars.Non_Terminal;
     46      Order : Anagram.Grammars.Ordered.Order_Maps.Map;
     47      NT    : Anagram.Grammars.Non_Terminal;
    4848      Pass  : Positive);
    4949
     
    5151     (Self      : access List_Generator;
    5252      Origin    : League.Strings.Universal_String;
    53       Attribute : Gela.Grammars.Attribute_Declaration);
     53      Attribute : Anagram.Grammars.Attribute_Declaration);
    5454
    5555   overriding procedure Make_Get
    5656     (Self      : access List_Generator;
    57       Attribute : Gela.Grammars.Attribute;
    58       Template  : Gela.Grammars.Rule_Templates.Rule_Template);
     57      Attribute : Anagram.Grammars.Attribute;
     58      Template  : Anagram.Grammars.Rule_Templates.Rule_Template);
    5959
    6060   overriding procedure Make_Set
    6161     (Self      : access List_Generator;
    62       Attribute : Gela.Grammars.Attribute);
     62      Attribute : Anagram.Grammars.Attribute);
    6363
    6464   type Abstract_Generator (Context : AG_Tools.Contexts.Context_Access)
     
    6767   overriding procedure Make_Procedure
    6868     (Self  : access Abstract_Generator;
    69       Order : Gela.Grammars.Ordered.Order_Maps.Map;
    70       NT    : Gela.Grammars.Non_Terminal;
     69      Order : Anagram.Grammars.Ordered.Order_Maps.Map;
     70      NT    : Anagram.Grammars.Non_Terminal;
    7171      Pass  : Positive);
    7272
     
    7474     (Self      : access Abstract_Generator;
    7575      Origin    : League.Strings.Universal_String;
    76       Attribute : Gela.Grammars.Attribute_Declaration) is null;
     76      Attribute : Anagram.Grammars.Attribute_Declaration) is null;
    7777
    7878   overriding procedure Make_Get
    7979     (Self      : access Abstract_Generator;
    80       Attribute : Gela.Grammars.Attribute;
    81       Template  : Gela.Grammars.Rule_Templates.Rule_Template) is null;
     80      Attribute : Anagram.Grammars.Attribute;
     81      Template  : Anagram.Grammars.Rule_Templates.Rule_Template) is null;
    8282
    8383   overriding procedure Make_Set
    8484     (Self      : access Abstract_Generator;
    85       Attribute : Gela.Grammars.Attribute) is null;
     85      Attribute : Anagram.Grammars.Attribute) is null;
    8686
    8787end AG_Tools.NT_Generators;
  • trunk/ada-2012/tools/ag/ag_tools-part_generators.adb

    r529 r537  
    99
    1010with AG_Tools.Writers;
    11 with Gela.Grammars.Ordered;
     11with Anagram.Grammars.Ordered;
    1212
    1313package body AG_Tools.Part_Generators is
     
    1919
    2020   function Origin
    21      (G         : Gela.Grammars.Grammar;
    22       Attribute : Gela.Grammars.Attribute)
     21     (G         : Anagram.Grammars.Grammar;
     22      Attribute : Anagram.Grammars.Attribute)
    2323      return League.Strings.Universal_String;
    2424
     
    2929   overriding procedure Make_Descent
    3030     (Self : access Generator;
    31       Part : Gela.Grammars.Part_Index;
     31      Part : Anagram.Grammars.Part_Index;
    3232      Pass : Positive)
    3333   is
    34       P    : Gela.Grammars.Part renames Self.Context.Grammar.Part (Part);
    35       NT   : Gela.Grammars.Non_Terminal renames
     34      P    : Anagram.Grammars.Part renames Self.Context.Grammar.Part (Part);
     35      NT   : Anagram.Grammars.Non_Terminal renames
    3636        Self.Context.Grammar.Non_Terminal (P.Denote);
    3737      Code : AG_Tools.Writers.Writer renames Self.Context.Code;
     
    5555   overriding procedure Make_Descent
    5656     (Self : access Option_Generator;
    57       Part : Gela.Grammars.Part_Index;
     57      Part : Anagram.Grammars.Part_Index;
    5858      Pass : Positive)
    5959   is
    60       P    : Gela.Grammars.Part renames Self.Context.Grammar.Part (Part);
     60      P    : Anagram.Grammars.Part renames Self.Context.Grammar.Part (Part);
    6161      Code : AG_Tools.Writers.Writer renames Self.Context.Code;
    6262   begin
     
    7676   overriding procedure Make_Descent
    7777     (Self : access List_Generator;
    78       Part : Gela.Grammars.Part_Index;
     78      Part : Anagram.Grammars.Part_Index;
    7979      Pass : Positive)
    8080   is
    81       G    : Gela.Grammars.Grammar renames Self.Context.Grammar.all;
    82       P    : Gela.Grammars.Part renames Self.Context.Grammar.Part (Part);
     81      G    : Anagram.Grammars.Grammar renames Self.Context.Grammar.all;
     82      P    : Anagram.Grammars.Part renames Self.Context.Grammar.Part (Part);
    8383      Code : AG_Tools.Writers.Writer renames Self.Context.Code;
    84       NT   : Gela.Grammars.Non_Terminal renames G.Non_Terminal (P.Denote);
    85       Parts : Gela.Grammars.Ordered.Partition_Array renames
     84      NT   : Anagram.Grammars.Non_Terminal renames G.Non_Terminal (P.Denote);
     85      Parts : Anagram.Grammars.Ordered.Partition_Array renames
    8686        Self.Context.Partition.all (NT.First_Attribute .. NT.Last_Attribute);
    8787   begin
     
    9898
    9999      for J in NT.First_Attribute .. NT.Last_Attribute loop
    100          if Gela.Grammars.Ordered.To_Pass (Parts, J) = Pass then
     100         if Anagram.Grammars.Ordered.To_Pass (Parts, J) = Pass then
    101101            Self.Make_Local_Variable
    102102              (P.Name, G.Declaration (J));
     
    118118   overriding procedure Make_Descent
    119119     (Self : access Head_Generator;
    120       Part : Gela.Grammars.Part_Index;
     120      Part : Anagram.Grammars.Part_Index;
    121121      Pass : Positive)
    122122   is
    123       G    : Gela.Grammars.Grammar renames Self.Context.Grammar.all;
    124       P    : Gela.Grammars.Part renames Self.Context.Grammar.Part (Part);
     123      G    : Anagram.Grammars.Grammar renames Self.Context.Grammar.all;
     124      P    : Anagram.Grammars.Part renames Self.Context.Grammar.Part (Part);
    125125      Code : AG_Tools.Writers.Writer renames Self.Context.Code;
    126       NT   : Gela.Grammars.Non_Terminal renames G.Non_Terminal (P.Denote);
    127       Parts : Gela.Grammars.Ordered.Partition_Array renames
     126      NT   : Anagram.Grammars.Non_Terminal renames G.Non_Terminal (P.Denote);
     127      Parts : Anagram.Grammars.Ordered.Partition_Array renames
    128128        Self.Context.Partition.all (NT.First_Attribute .. NT.Last_Attribute);
    129129   begin
     
    136136
    137137      for J in NT.First_Attribute .. NT.Last_Attribute loop
    138          if Gela.Grammars.Ordered.To_Pass (Parts, J) = Pass then
     138         if Anagram.Grammars.Ordered.To_Pass (Parts, J) = Pass then
    139139            Self.Make_Local_Variable
    140140              (P.Name, G.Declaration (J));
     
    156156   overriding procedure Make_Get
    157157     (Self      : access Generator;
    158       Attribute : Gela.Grammars.Attribute;
    159       Template  : Gela.Grammars.Rule_Templates.Rule_Template)
     158      Attribute : Anagram.Grammars.Attribute;
     159      Template  : Anagram.Grammars.Rule_Templates.Rule_Template)
    160160   is
    161161      pragma Unreferenced (Template);
    162       G    : Gela.Grammars.Grammar renames Self.Context.Grammar.all;
     162      G    : Anagram.Grammars.Grammar renames Self.Context.Grammar.all;
    163163      Origin : League.Strings.Universal_String;
    164164      Code   : AG_Tools.Writers.Writer renames Self.Context.Code;
    165       D      : Gela.Grammars.Attribute_Declaration renames
     165      D      : Anagram.Grammars.Attribute_Declaration renames
    166166        G.Declaration (Attribute.Declaration);
    167167   begin
     
    191191   overriding procedure Make_Get
    192192     (Self      : access Head_Generator;
    193       Attribute : Gela.Grammars.Attribute;
    194       Template  : Gela.Grammars.Rule_Templates.Rule_Template)
     193      Attribute : Anagram.Grammars.Attribute;
     194      Template  : Anagram.Grammars.Rule_Templates.Rule_Template)
    195195   is
    196196      pragma Unreferenced (Template);
    197197
    198       G    : Gela.Grammars.Grammar renames Self.Context.Grammar.all;
     198      G    : Anagram.Grammars.Grammar renames Self.Context.Grammar.all;
    199199      Code : AG_Tools.Writers.Writer renames Self.Context.Code;
    200       D    : Gela.Grammars.Attribute_Declaration renames
     200      D    : Anagram.Grammars.Attribute_Declaration renames
    201201        G.Declaration (Attribute.Declaration);
    202202   begin
     
    211211   overriding procedure Make_Get
    212212     (Self      : access List_Generator;
    213       Attribute : Gela.Grammars.Attribute;
    214       Template  : Gela.Grammars.Rule_Templates.Rule_Template)
     213      Attribute : Anagram.Grammars.Attribute;
     214      Template  : Anagram.Grammars.Rule_Templates.Rule_Template)
    215215   is
    216216      pragma Unreferenced (Template);
    217       G      : Gela.Grammars.Grammar renames Self.Context.Grammar.all;
     217      G      : Anagram.Grammars.Grammar renames Self.Context.Grammar.all;
    218218      Code   : AG_Tools.Writers.Writer renames Self.Context.Code;
    219219   begin
     
    231231   overriding procedure Make_Get
    232232     (Self      : access Option_Generator;
    233       Attribute : Gela.Grammars.Attribute;
    234       Template  : Gela.Grammars.Rule_Templates.Rule_Template)
     233      Attribute : Anagram.Grammars.Attribute;
     234      Template  : Anagram.Grammars.Rule_Templates.Rule_Template)
    235235   is
    236236      use type League.Strings.Universal_String;
    237       G      : Gela.Grammars.Grammar renames Self.Context.Grammar.all;
     237      G      : Anagram.Grammars.Grammar renames Self.Context.Grammar.all;
    238238      Code   : AG_Tools.Writers.Writer renames Self.Context.Code;
    239239      Part   : constant League.Strings.Universal_String :=
     
    274274     (Self      : access Generator;
    275275      Origin    : League.Strings.Universal_String;
    276       Attribute : Gela.Grammars.Attribute_Declaration)
     276      Attribute : Anagram.Grammars.Attribute_Declaration)
    277277   is
    278278      Impl : AG_Tools.Writers.Writer renames Self.Context.Impl;
     
    301301   overriding procedure Make_Local_Variable
    302302     (Self : access Generator;
    303       Part : Gela.Grammars.Part_Index)
    304    is
    305       G    : Gela.Grammars.Grammar renames Self.Context.Grammar.all;
    306       P    : Gela.Grammars.Part renames G.Part (Part);
     303      Part : Anagram.Grammars.Part_Index)
     304   is
     305      G    : Anagram.Grammars.Grammar renames Self.Context.Grammar.all;
     306      P    : Anagram.Grammars.Part renames G.Part (Part);
    307307      Impl : AG_Tools.Writers.Writer renames Self.Context.Impl;
    308       Prod : Gela.Grammars.Production renames G.Production (P.Parent);
    309       NT   : Gela.Grammars.Non_Terminal renames G.Non_Terminal (Prod.Parent);
     308      Prod : Anagram.Grammars.Production renames G.Production (P.Parent);
     309      NT   : Anagram.Grammars.Non_Terminal renames
     310               G.Non_Terminal (Prod.Parent);
    310311      RT   : constant League.Strings.Universal_String := Return_Type (G, P);
    311312   begin
     
    342343   overriding procedure Make_Set
    343344     (Self      : access Generator;
    344       Attribute : Gela.Grammars.Attribute)
    345    is
    346       G      : Gela.Grammars.Grammar renames Self.Context.Grammar.all;
     345      Attribute : Anagram.Grammars.Attribute)
     346   is
     347      G      : Anagram.Grammars.Grammar renames Self.Context.Grammar.all;
    347348      Origin : League.Strings.Universal_String;
    348349      Code   : AG_Tools.Writers.Writer renames Self.Context.Code;
    349       D      : Gela.Grammars.Attribute_Declaration renames
     350      D      : Anagram.Grammars.Attribute_Declaration renames
    350351        G.Declaration (Attribute.Declaration);
    351352   begin
     
    371372   overriding procedure Make_Set
    372373     (Self      : access Head_Generator;
    373       Attribute : Gela.Grammars.Attribute)
    374    is
    375       G      : Gela.Grammars.Grammar renames Self.Context.Grammar.all;
    376       Code   : AG_Tools.Writers.Writer renames Self.Context.Code;
    377       D      : Gela.Grammars.Attribute_Declaration renames
     374      Attribute : Anagram.Grammars.Attribute)
     375   is
     376      G      : Anagram.Grammars.Grammar renames Self.Context.Grammar.all;
     377      Code   : AG_Tools.Writers.Writer renames Self.Context.Code;
     378      D      : Anagram.Grammars.Attribute_Declaration renames
    378379        G.Declaration (Attribute.Declaration);
    379380   begin
     
    388389   overriding procedure Make_Set
    389390     (Self      : access List_Generator;
    390       Attribute : Gela.Grammars.Attribute)
    391    is
    392       G      : Gela.Grammars.Grammar renames Self.Context.Grammar.all;
     391      Attribute : Anagram.Grammars.Attribute)
     392   is
     393      G      : Anagram.Grammars.Grammar renames Self.Context.Grammar.all;
    393394      Code   : AG_Tools.Writers.Writer renames Self.Context.Code;
    394395   begin
     
    406407   overriding procedure Make_Set
    407408     (Self : access Option_Generator;
    408       Attribute : Gela.Grammars.Attribute)
    409    is
    410       G      : Gela.Grammars.Grammar renames Self.Context.Grammar.all;
     409      Attribute : Anagram.Grammars.Attribute)
     410   is
     411      G      : Anagram.Grammars.Grammar renames Self.Context.Grammar.all;
    411412      Origin : League.Strings.Universal_String;
    412413      Code   : AG_Tools.Writers.Writer renames Self.Context.Code;
     
    425426
    426427   function Origin
    427      (G         : Gela.Grammars.Grammar;
    428       Attribute : Gela.Grammars.Attribute)
     428     (G         : Anagram.Grammars.Grammar;
     429      Attribute : Anagram.Grammars.Attribute)
    429430      return League.Strings.Universal_String
    430431   is
    431       Rule : Gela.Grammars.Rule renames G.Rule (Attribute.Parent);
    432       Prod : Gela.Grammars.Production renames G.Production (Rule.Parent);
    433       NT   : Gela.Grammars.Non_Terminal renames G.Non_Terminal (Prod.Parent);
     432      Rule : Anagram.Grammars.Rule renames G.Rule (Attribute.Parent);
     433      Prod : Anagram.Grammars.Production renames G.Production (Rule.Parent);
     434      NT   : Anagram.Grammars.Non_Terminal renames
     435               G.Non_Terminal (Prod.Parent);
    434436   begin
    435437      if Attribute.Is_Left_Hand_Side then
  • trunk/ada-2012/tools/ag/ag_tools-part_generators.ads

    r415 r537  
    1010with AG_Tools.Contexts;
    1111with AG_Tools.Visit_Generators;
    12 with Gela.Grammars.Rule_Templates;
     12with Anagram.Grammars.Rule_Templates;
    1313
    1414package AG_Tools.Part_Generators is
     
    1919   overriding procedure Make_Descent
    2020     (Self : access Generator;
    21       Part : Gela.Grammars.Part_Index;
     21      Part : Anagram.Grammars.Part_Index;
    2222      Pass : Positive);
    2323
     
    2525     (Self      : access Generator;
    2626      Origin    : League.Strings.Universal_String;
    27       Attribute : Gela.Grammars.Attribute_Declaration);
     27      Attribute : Anagram.Grammars.Attribute_Declaration);
    2828
    2929   overriding procedure Make_Local_Variable
    3030     (Self : access Generator;
    31       Part : Gela.Grammars.Part_Index);
     31      Part : Anagram.Grammars.Part_Index);
    3232
    3333   overriding procedure Make_Get
    3434     (Self      : access Generator;
    35       Attribute : Gela.Grammars.Attribute;
    36       Template  : Gela.Grammars.Rule_Templates.Rule_Template);
     35      Attribute : Anagram.Grammars.Attribute;
     36      Template  : Anagram.Grammars.Rule_Templates.Rule_Template);
    3737
    3838   overriding procedure Make_Set
    3939     (Self      : access Generator;
    40       Attribute : Gela.Grammars.Attribute);
     40      Attribute : Anagram.Grammars.Attribute);
    4141
    4242   type List_Generator (Context : AG_Tools.Contexts.Context_Access)
     
    4545   overriding procedure Make_Descent
    4646     (Self : access List_Generator;
    47       Part : Gela.Grammars.Part_Index;
     47      Part : Anagram.Grammars.Part_Index;
    4848      Pass : Positive);
    4949
    5050   overriding procedure Make_Get
    5151     (Self      : access List_Generator;
    52       Attribute : Gela.Grammars.Attribute;
    53       Template  : Gela.Grammars.Rule_Templates.Rule_Template);
     52      Attribute : Anagram.Grammars.Attribute;
     53      Template  : Anagram.Grammars.Rule_Templates.Rule_Template);
    5454
    5555   overriding procedure Make_Set
    5656     (Self      : access List_Generator;
    57       Attribute : Gela.Grammars.Attribute);
     57      Attribute : Anagram.Grammars.Attribute);
    5858
    5959   type Option_Generator (Context : AG_Tools.Contexts.Context_Access)
     
    6262   overriding procedure Make_Descent
    6363     (Self : access Option_Generator;
    64       Part : Gela.Grammars.Part_Index;
     64      Part : Anagram.Grammars.Part_Index;
    6565      Pass : Positive);
    6666
    6767   overriding procedure Make_Get
    6868     (Self      : access Option_Generator;
    69       Attribute : Gela.Grammars.Attribute;
    70       Template  : Gela.Grammars.Rule_Templates.Rule_Template);
     69      Attribute : Anagram.Grammars.Attribute;
     70      Template  : Anagram.Grammars.Rule_Templates.Rule_Template);
    7171
    7272   overriding procedure Make_Set
    7373     (Self      : access Option_Generator;
    74       Attribute : Gela.Grammars.Attribute);
     74      Attribute : Anagram.Grammars.Attribute);
    7575
    7676   type Head_Generator (Context : AG_Tools.Contexts.Context_Access)
     
    7979   overriding procedure Make_Descent
    8080     (Self : access Head_Generator;
    81       Part : Gela.Grammars.Part_Index;
     81      Part : Anagram.Grammars.Part_Index;
    8282      Pass : Positive);
    8383
    8484   overriding procedure Make_Set
    8585     (Self      : access Head_Generator;
    86       Attribute : Gela.Grammars.Attribute);
     86      Attribute : Anagram.Grammars.Attribute);
    8787
    8888   overriding procedure Make_Get
    8989     (Self      : access Head_Generator;
    90       Attribute : Gela.Grammars.Attribute;
    91       Template  : Gela.Grammars.Rule_Templates.Rule_Template);
     90      Attribute : Anagram.Grammars.Attribute;
     91      Template  : Anagram.Grammars.Rule_Templates.Rule_Template);
    9292
    9393end AG_Tools.Part_Generators;
  • trunk/ada-2012/tools/ag/ag_tools-prop_setter.adb

    r482 r537  
    1313   --------------
    1414
    15    procedure Generate (G : Gela.Grammars.Grammar_Access) is
     15   procedure Generate (G : Anagram.Grammars.Grammar_Access) is
    1616      use type League.Strings.Universal_String;
    17       use type Gela.Grammars.Attribute_Declaration_Index;
     17      use type Anagram.Grammars.Attribute_Declaration_Index;
    1818
    1919      Context : aliased AG_Tools.Contexts.Context;
  • trunk/ada-2012/tools/ag/ag_tools-prop_setter.ads

    r476 r537  
    11package AG_Tools.Prop_Setter is
    2    procedure Generate (G : Gela.Grammars.Grammar_Access);
     2   procedure Generate (G : Anagram.Grammars.Grammar_Access);
    33end AG_Tools.Prop_Setter;
  • trunk/ada-2012/tools/ag/ag_tools-prop_visiters.adb

    r460 r537  
    1313   --------------
    1414
    15    procedure Generate (G : Gela.Grammars.Grammar_Access) is
     15   procedure Generate (G : Anagram.Grammars.Grammar_Access) is
    1616      use type League.Strings.Universal_String;
    17       use type Gela.Grammars.Attribute_Declaration_Index;
     17      use type Anagram.Grammars.Attribute_Declaration_Index;
    1818
    1919      Context : aliased AG_Tools.Contexts.Context;
  • trunk/ada-2012/tools/ag/ag_tools-prop_visiters.ads

    r415 r537  
    11package AG_Tools.Prop_Visiters is
    2    procedure Generate (G : Gela.Grammars.Grammar_Access);
     2   procedure Generate (G : Anagram.Grammars.Grammar_Access);
    33end AG_Tools.Prop_Visiters;
  • trunk/ada-2012/tools/ag/ag_tools-visit_generators.ads

    r415 r537  
    1010with League.Strings;
    1111
    12 with Gela.Grammars.Ordered;
    13 with Gela.Grammars.Rule_Templates;
     12with Anagram.Grammars.Ordered;
     13with Anagram.Grammars.Rule_Templates;
    1414
    1515package AG_Tools.Visit_Generators is
     
    2121     (Self      : access Generator;
    2222      Origin    : League.Strings.Universal_String;
    23       Attribute : Gela.Grammars.Attribute_Declaration) is abstract;
     23      Attribute : Anagram.Grammars.Attribute_Declaration) is abstract;
    2424   --  Generate local variable to store value of given Attribute
    2525
    2626   not overriding procedure Make_Get
    2727     (Self      : access Generator;
    28       Attribute : Gela.Grammars.Attribute;
    29       Template  : Gela.Grammars.Rule_Templates.Rule_Template) is abstract;
     28      Attribute : Anagram.Grammars.Attribute;
     29      Template  : Anagram.Grammars.Rule_Templates.Rule_Template) is abstract;
    3030   --  Generate code to get/fetch value of given Attribute
    3131
    3232   not overriding procedure Make_Set
    3333     (Self      : access Generator;
    34       Attribute : Gela.Grammars.Attribute) is abstract;
     34      Attribute : Anagram.Grammars.Attribute) is abstract;
    3535   --  Generate code to set/update value in given Attribute
    3636
     
    4040   not overriding procedure Make_Descent
    4141     (Self : access Part_Generator;
    42       Part : Gela.Grammars.Part_Index;
     42      Part : Anagram.Grammars.Part_Index;
    4343      Pass : Positive) is abstract;
    4444   --  Generate code to go deeper in the tree
     
    4646   not overriding procedure Make_Local_Variable
    4747     (Self : access Part_Generator;
    48       Part : Gela.Grammars.Part_Index) is abstract;
     48      Part : Anagram.Grammars.Part_Index) is abstract;
    4949   --  Generate local variable to store value of given Attribute
    5050
     
    5454   not overriding procedure Make_Procedure
    5555     (Self  : access NT_Generator;
    56       Order : Gela.Grammars.Ordered.Order_Maps.Map;
    57       NT    : Gela.Grammars.Non_Terminal;
     56      Order : Anagram.Grammars.Ordered.Order_Maps.Map;
     57      NT    : Anagram.Grammars.Non_Terminal;
    5858      Pass  : Positive) is abstract;
    5959   --  Generate procedure
     
    6464   not overriding function Get
    6565     (Self : access Factory;
    66       NT   : Gela.Grammars.Non_Terminal)
     66      NT   : Anagram.Grammars.Non_Terminal)
    6767      return NT_Generator_Access is abstract;
    6868
    6969   not overriding function Get
    7070     (Self : access Factory;
    71       Part : Gela.Grammars.Part)
     71      Part : Anagram.Grammars.Part)
    7272      return Part_Generator_Access is abstract;
    7373
    7474   not overriding function Get
    7575     (Self : access Factory;
    76       Attr : Gela.Grammars.Attribute;
    77       NT   : Gela.Grammars.Non_Terminal)
     76      Attr : Anagram.Grammars.Attribute;
     77      NT   : Anagram.Grammars.Non_Terminal)
    7878      return AG_Tools.Visit_Generators.Generator_Access is abstract;
    7979
  • trunk/ada-2012/tools/ag/ag_tools.adb

    r529 r537  
    1717
    1818   function Is_Converted_List
    19      (G  : Gela.Grammars.Grammar;
    20       NT : Gela.Grammars.Non_Terminal) return Boolean
     19     (G  : Anagram.Grammars.Grammar;
     20      NT : Anagram.Grammars.Non_Terminal) return Boolean
    2121   is
    22       use type Gela.Grammars.Part_Index;
     22      use type Anagram.Grammars.Part_Index;
    2323
    24       Prod : Gela.Grammars.Production renames G.Production (NT.Last);
     24      Prod : Anagram.Grammars.Production renames G.Production (NT.Last);
    2525   begin
    2626      return Prod.First > Prod.Last;
     
    3232
    3333   function List_Item
    34      (G : Gela.Grammars.Grammar;
    35       NT : Gela.Grammars.Non_Terminal)
    36       return Gela.Grammars.Non_Terminal_Index
     34     (G : Anagram.Grammars.Grammar;
     35      NT : Anagram.Grammars.Non_Terminal)
     36      return Anagram.Grammars.Non_Terminal_Index
    3737   is
    38       Prod : Gela.Grammars.Production renames G.Production (NT.First);
    39       Part : Gela.Grammars.Part renames G.Part (Prod.First);
     38      Prod : Anagram.Grammars.Production renames G.Production (NT.First);
     39      Part : Anagram.Grammars.Part renames G.Part (Prod.First);
    4040   begin
    4141      return Part.Denote;
     
    105105
    106106   function Return_Type
    107      (G    : Gela.Grammars.Grammar;
    108       Part : Gela.Grammars.Part)
     107     (G    : Anagram.Grammars.Grammar;
     108      Part : Anagram.Grammars.Part)
    109109      return League.Strings.Universal_String
    110110   is
    111       use Gela.Grammars;
     111      use Anagram.Grammars;
    112112
    113113      Result : League.Strings.Universal_String;
     
    119119
    120120         declare
    121             Prod : Gela.Grammars.Production renames
     121            Prod : Anagram.Grammars.Production renames
    122122              G.Production (Part.First);
    123123         begin
     
    133133      else
    134134         declare
    135             NT : Gela.Grammars.Non_Terminal renames
     135            NT : Anagram.Grammars.Non_Terminal renames
    136136              G.Non_Terminal (Part.Denote);
    137137         begin
     
    149149
    150150   function Return_Type
    151      (G  : Gela.Grammars.Grammar;
    152       NT : Gela.Grammars.Non_Terminal)
     151     (G  : Anagram.Grammars.Grammar;
     152      NT : Anagram.Grammars.Non_Terminal)
    153153      return League.Strings.Universal_String
    154154   is
     
    156156
    157157      Result : League.Strings.Universal_String;
    158       Prod : Gela.Grammars.Production renames G.Production (NT.First);
     158      Prod : Anagram.Grammars.Production renames G.Production (NT.First);
    159159   begin
    160160      if NT.Is_List or Is_Converted_List (G, NT) then
  • trunk/ada-2012/tools/ag/ag_tools.ads

    r415 r537  
    99
    1010with League.Strings;
    11 with Gela.Grammars;
     11with Anagram.Grammars;
    1212
    1313package AG_Tools is
     
    2525
    2626   function Return_Type
    27      (G    : Gela.Grammars.Grammar;
    28       Part : Gela.Grammars.Part)
     27     (G    : Anagram.Grammars.Grammar;
     28      Part : Anagram.Grammars.Part)
    2929      return League.Strings.Universal_String;
    3030   --  Get identifier of type of given Part
    3131
    3232   function Return_Type
    33      (G  : Gela.Grammars.Grammar;
    34       NT : Gela.Grammars.Non_Terminal)
     33     (G  : Anagram.Grammars.Grammar;
     34      NT : Anagram.Grammars.Non_Terminal)
    3535      return League.Strings.Universal_String;
    3636   --  Get identifier of type of given Part
     
    4141
    4242   function Is_Converted_List
    43      (G  : Gela.Grammars.Grammar;
    44       NT : Gela.Grammars.Non_Terminal) return Boolean;
     43     (G  : Anagram.Grammars.Grammar;
     44      NT : Anagram.Grammars.Non_Terminal) return Boolean;
    4545   --  Detect if NT was a list before converting to plain AG
    4646
    4747   function List_Item
    48      (G : Gela.Grammars.Grammar;
    49       NT : Gela.Grammars.Non_Terminal)
    50       return Gela.Grammars.Non_Terminal_Index;
     48     (G : Anagram.Grammars.Grammar;
     49      NT : Anagram.Grammars.Non_Terminal)
     50      return Anagram.Grammars.Non_Terminal_Index;
    5151   --  Return items non-terminal for list, like NT={item}
    5252
  • trunk/ada-2012/tools/ag/to_ayacc.adb

    r415 r537  
    11with Ada.Command_Line;
    22with Ada.Wide_Wide_Text_IO;
    3 with Gela.Grammars.AYACC;
    4 with Gela.Grammars.Reader;
    5 with Gela.Grammars_Convertors;
    6 --  with Gela.Grammars_Debug;
     3with Anagram.Grammars.AYACC;
     4with Anagram.Grammars.Reader;
     5with Anagram.Grammars_Convertors;
     6--  with Anagram.Grammars_Debug;
    77
    8 with Gela.Grammars.Tools;
     8with Anagram.Grammars.Tools;
    99
    1010procedure To_AYACC is
    1111   File  : constant String := Ada.Command_Line.Argument (1);
    12    G     : constant Gela.Grammars.Grammar := Gela.Grammars.Reader.Read (File);
    13    Plain : constant Gela.Grammars.Grammar :=
    14      Gela.Grammars_Convertors.Convert (G, Left => False);
     12   G     : constant Anagram.Grammars.Grammar :=
     13     Anagram.Grammars.Reader.Read (File);
     14   Plain : constant Anagram.Grammars.Grammar :=
     15     Anagram.Grammars_Convertors.Convert (G, Left => False);
    1516begin
    16 --   Gela.Grammars_Debug.Print (G);
    17    Gela.Grammars.AYACC.Write (Plain);
     17--   Anagram.Grammars_Debug.Print (G);
     18   Anagram.Grammars.AYACC.Write (Plain);
    1819
    1920   if Ada.Command_Line.Argument_Count = 1 then
     
    2223
    2324   declare
    24       use Gela.Grammars.Tools;
     25      use Anagram.Grammars.Tools;
    2526      First  : Terminal_Set_Per_Non_Terminal
    2627        (Plain.Last_Terminal, Plain.Last_Non_Terminal);
     
    2829        (Plain.Last_Terminal, Plain.Last_Non_Terminal);
    2930   begin
    30       Gela.Grammars.Tools.Get_First (Plain, First);
    31       Gela.Grammars.Tools.Get_Follow (Plain, First, Follow);
     31      Anagram.Grammars.Tools.Get_First (Plain, First);
     32      Anagram.Grammars.Tools.Get_Follow (Plain, First, Follow);
    3233
    3334      for NT of Plain.Non_Terminal loop
  • trunk/ada-2012/tools/ag/yacc_driver.adb

    r529 r537  
    1010with Ada.Text_IO;
    1111
    12 with Gela.Grammars;
    13 with Gela.Grammars.Reader;
    14 with Gela.Grammars_Convertors;
    15 with Gela.Grammars.Rule_Templates;
    16 with Gela.Grammars_Debug;
    17 with Gela.Grammars.LR_Tables;
    18 with Gela.Grammars.LR.LALR;
    19 with Gela.Grammars.Constructors;
    20 with Gela.Grammars.Conflicts;
     12with Anagram.Grammars;
     13with Anagram.Grammars.Reader;
     14with Anagram.Grammars_Convertors;
     15with Anagram.Grammars.Rule_Templates;
     16with Anagram.Grammars_Debug;
     17with Anagram.Grammars.LR_Tables;
     18with Anagram.Grammars.LR.LALR;
     19with Anagram.Grammars.Constructors;
     20with Anagram.Grammars.Conflicts;
    2121with AG_Tools.Writers;                 use AG_Tools.Writers;
    2222
     
    2626procedure YACC_Driver is
    2727
    28    use type Gela.Grammars.Rule_Count;
    29    use type Gela.Grammars.LR.State_Count;
     28   use type Anagram.Grammars.Rule_Count;
     29   use type Anagram.Grammars.LR.State_Count;
    3030
    3131   procedure Put_Proc_Decl
     
    3535   procedure Put_Piece
    3636     (Piece : in out Writer;
    37       From  : Gela.Grammars.Production_Index;
    38       To    : Gela.Grammars.Production_Index);
     37      From  : Anagram.Grammars.Production_Index;
     38      To    : Anagram.Grammars.Production_Index);
    3939
    4040   procedure Put_Rule
    4141     (Output : in out Writer;
    42       Prod   : Gela.Grammars.Production;
    43       Rule   : Gela.Grammars.Rule);
     42      Prod   : Anagram.Grammars.Production;
     43      Rule   : Anagram.Grammars.Rule);
    4444
    4545   function Image (X : Integer) return Wide_Wide_String;
     
    4949
    5050   File  : constant String := Ada.Command_Line.Argument (1);
    51    G     : constant Gela.Grammars.Grammar := Gela.Grammars.Reader.Read (File);
    52    Plain : constant Gela.Grammars.Grammar :=
    53      Gela.Grammars_Convertors.Convert (G, Left => False);
    54    AG    : constant Gela.Grammars.Grammar :=
    55      Gela.Grammars.Constructors.To_Augmented (Plain);
    56    Table : constant Gela.Grammars.LR_Tables.Table_Access :=
    57      Gela.Grammars.LR.LALR.Build
     51   G     : constant Anagram.Grammars.Grammar :=
     52     Anagram.Grammars.Reader.Read (File);
     53   Plain : constant Anagram.Grammars.Grammar :=
     54     Anagram.Grammars_Convertors.Convert (G, Left => False);
     55   AG    : constant Anagram.Grammars.Grammar :=
     56     Anagram.Grammars.Constructors.To_Augmented (Plain);
     57   Table : constant Anagram.Grammars.LR_Tables.Table_Access :=
     58     Anagram.Grammars.LR.LALR.Build
    5859       (Input        => AG,
    5960        Right_Nulled => False);
    60    Resolver : Gela.Grammars.Conflicts.Resolver;
     61   Resolver : Anagram.Grammars.Conflicts.Resolver;
    6162   Output : Writer;
    6263
     
    7677
    7778   procedure Print_Action is
    78       use type Gela.Grammars.Production_Count;
    79       use type Gela.Grammars.Part_Count;
     79      use type Anagram.Grammars.Production_Count;
     80      use type Anagram.Grammars.Part_Count;
    8081      type Action_Code is mod 2 ** 16;
    8182
     
    8889      Output.P ("   Action_Table : constant array");
    8990      Output.N ("     (State_Index range 1 .. ");
    90       Output.N (Natural (Gela.Grammars.LR_Tables.Last_State (Table.all)));
     91      Output.N (Natural (Anagram.Grammars.LR_Tables.Last_State (Table.all)));
    9192      Output.P (",");
    92       Output.N ("      Gela.Grammars.Terminal_Count range 0 .. ");
     93      Output.N ("      Anagram.Grammars.Terminal_Count range 0 .. ");
    9394      Output.N (Natural (Plain.Last_Terminal));
    9495      Output.P (") of Action_Code :=");
    9596
    96       for State in 1 .. Gela.Grammars.LR_Tables.Last_State (Table.all) loop
     97      for State in 1 .. Anagram.Grammars.LR_Tables.Last_State (Table.all) loop
    9798         if State = 1 then
    9899            Output.N ("     (");
     
    108109         for T in 0 .. Plain.Last_Terminal loop
    109110            declare
    110                use Gela.Grammars.LR_Tables;
    111                S : constant Gela.Grammars.LR.State_Count :=
     111               use Anagram.Grammars.LR_Tables;
     112               S : constant Anagram.Grammars.LR.State_Count :=
    112113                 Shift (Table.all, State, T);
    113114               R : constant Reduce_Iterator := Reduce (Table.all, State, T);
     
    142143      Output.P;
    143144      Output.P ("   type Production_Record is record");
    144       Output.P ("      NT    : Gela.Grammars.Non_Terminal_Index;");
     145      Output.P ("      NT    : Anagram.Grammars.Non_Terminal_Index;");
    145146      Output.P ("      Parts : Natural;");
    146147      Output.P ("   end record;");
     
    176177
    177178      Output.P ("   procedure Next_Action");
    178       Output.P ("     (State : Gela.Grammars.LR_Parsers.State_Index;");
    179       Output.P ("      Token : Gela.Grammars.Terminal_Count;");
    180       Output.P ("      Value : out Gela.Grammars.LR_Parsers.Action)");
     179      Output.P ("     (State : Anagram.Grammars.LR_Parsers.State_Index;");
     180      Output.P ("      Token : Anagram.Grammars.Terminal_Count;");
     181      Output.P ("      Value : out Anagram.Grammars.LR_Parsers.Action)");
    181182      Output.P ("   is");
    182183      Output.P ("      Code : constant Action_Code := " &
     
    189190      Output.P ("         Value := (Kind  => Reduce,");
    190191      Output.P ("                   Prod  => " &
    191                   "Gela.Grammars.Production_Index (Code),");
     192                  "Anagram.Grammars.Production_Index (Code),");
    192193      Output.P ("                   NT    => Prods (Code).NT,");
    193194      Output.P ("                   Parts => Prods (Code).Parts);");
    194195
    195       for State in 1 .. Gela.Grammars.LR_Tables.Last_State (Table.all) loop
    196          if Gela.Grammars.LR_Tables.Finish (Table.all, State) then
     196      for State in 1 .. Anagram.Grammars.LR_Tables.Last_State (Table.all) loop
     197         if Anagram.Grammars.LR_Tables.Finish (Table.all, State) then
    197198            Output.N ("      elsif State = ");
    198199            Output.N (Natural (State));
     
    217218   begin
    218219      Output.P ("   Go_To_Table : constant array");
    219       Output.N ("     (Gela.Grammars.LR_Parsers.State_Index range 1 .. ");
    220       Output.N (Natural (Gela.Grammars.LR_Tables.Last_State (Table.all)));
     220      Output.N ("     (Anagram.Grammars.LR_Parsers.State_Index range 1 .. ");
     221      Output.N (Natural (Anagram.Grammars.LR_Tables.Last_State (Table.all)));
    221222      Output.P (",");
    222       Output.N ("      Gela.Grammars.Non_Terminal_Index range 1 .. ");
     223      Output.N ("      Anagram.Grammars.Non_Terminal_Index range 1 .. ");
    223224      Output.N (Natural (Plain.Last_Non_Terminal));
    224225      Output.P (") of State_Index :=");
    225226
    226       for State in 1 .. Gela.Grammars.LR_Tables.Last_State (Table.all) loop
     227      for State in 1 .. Anagram.Grammars.LR_Tables.Last_State (Table.all) loop
    227228         if State = 1 then
    228229            Output.N ("     (");
     
    238239         for NT in 1 .. Plain.Last_Non_Terminal loop
    239240            declare
    240                use Gela.Grammars.LR;
     241               use Anagram.Grammars.LR;
    241242               Next : constant State_Count :=
    242                  Gela.Grammars.LR_Tables.Shift (Table.all, State, NT);
     243                 Anagram.Grammars.LR_Tables.Shift (Table.all, State, NT);
    243244            begin
    244245               if Next /= 0 then
     
    263264
    264265      Output.P ("   function Go_To");
    265       Output.P ("     (State : Gela.Grammars.LR_Parsers.State_Index;");
    266       Output.P ("      NT    : Gela.Grammars.Non_Terminal_Index)");
    267       Output.P ("      return Gela.Grammars.LR_Parsers.State_Index");
     266      Output.P ("     (State : Anagram.Grammars.LR_Parsers.State_Index;");
     267      Output.P ("      NT    : Anagram.Grammars.Non_Terminal_Index)");
     268      Output.P ("      return Anagram.Grammars.LR_Parsers.State_Index");
    268269      Output.P ("   is");
    269270      Output.P ("   begin");
     
    279280   procedure Put_Rule
    280281     (Output : in out Writer;
    281       Prod   : Gela.Grammars.Production;
    282       Rule   : Gela.Grammars.Rule)
     282      Prod   : Anagram.Grammars.Production;
     283      Rule   : Anagram.Grammars.Rule)
    283284   is
    284       use Gela.Grammars.Rule_Templates;
     285      use Anagram.Grammars.Rule_Templates;
    285286      use type League.Strings.Universal_String;
    286287      Template : constant Rule_Template := Create (Rule.Text);
     
    339340      Output.P (Suffix);
    340341      Output.P ("  (Self  : access Parser_Context;");
    341       Output.P ("   Prod  : Gela.Grammars.Production_Index;");
     342      Output.P ("   Prod  : Anagram.Grammars.Production_Index;");
    342343      Output.N ("   Nodes : in out " &
    343344                  "Gela.LARL_Parsers_Nodes.Node_Array)");
     
    346347   procedure Put_Piece
    347348     (Piece : in out Writer;
    348       From  : Gela.Grammars.Production_Index;
    349       To    : Gela.Grammars.Production_Index)
     349      From  : Anagram.Grammars.Production_Index;
     350      To    : Anagram.Grammars.Production_Index)
    350351   is
    351352      Suffix : Wide_Wide_String :=
    352         Gela.Grammars.Production_Index'Wide_Wide_Image (From);
     353        Anagram.Grammars.Production_Index'Wide_Wide_Image (From);
    353354   begin
    354355      Suffix (1) := '_';
    355356
    356       Piece.P ("with Gela.Grammars;");
     357      Piece.P ("with Anagram.Grammars;");
    357358      Piece.P ("with Gela.LARL_Parsers_Nodes;");
    358359      Piece.N ("private ");
     
    412413      for Prod of Plain.Production (From .. To) loop
    413414         Piece.N ("      when");
    414          Piece.N (Gela.Grammars.Production_Index'Wide_Wide_Image (Prod.Index));
     415         Piece.N
     416           (Anagram.Grammars.Production_Index'Wide_Wide_Image (Prod.Index));
    415417         Piece.P (" =>");
    416418
     
    432434   end Put_Piece;
    433435
    434    use type Gela.Grammars.Production_Count;
    435 
    436    Piece_Length : constant Gela.Grammars.Production_Count := 500;
     436   use type Anagram.Grammars.Production_Count;
     437
     438   Piece_Length : constant Anagram.Grammars.Production_Count := 500;
    437439
    438440   Piece : Writer;
     
    440442   Resolver.Resolve (AG, Table.all);
    441443
    442    Output.P ("with Gela.Grammars;");
    443    Output.P ("with Gela.Grammars.LR_Parsers;");
     444   Output.P ("with Anagram.Grammars;");
     445   Output.P ("with Anagram.Grammars.LR_Parsers;");
    444446   Output.P;
    445447   Output.P ("package Gela.LARL_Parsers.Data is");
     
    447449   Output.P;
    448450   Output.P ("   procedure Next_Action");
    449    Output.P ("     (State : Gela.Grammars.LR_Parsers.State_Index;");
    450    Output.P ("      Token : Gela.Grammars.Terminal_Count;");
    451    Output.P ("      Value : out Gela.Grammars.LR_Parsers.Action);");
     451   Output.P ("     (State : Anagram.Grammars.LR_Parsers.State_Index;");
     452   Output.P ("      Token : Anagram.Grammars.Terminal_Count;");
     453   Output.P ("      Value : out Anagram.Grammars.LR_Parsers.Action);");
    452454   Output.P;
    453455   Output.P ("   function Go_To");
    454    Output.P ("     (State : Gela.Grammars.LR_Parsers.State_Index;");
    455    Output.P ("      NT    : Gela.Grammars.Non_Terminal_Index)");
    456    Output.P ("      return Gela.Grammars.LR_Parsers.State_Index;");
     456   Output.P ("     (State : Anagram.Grammars.LR_Parsers.State_Index;");
     457   Output.P ("      NT    : Anagram.Grammars.Non_Terminal_Index)");
     458   Output.P ("      return Anagram.Grammars.LR_Parsers.State_Index;");
    457459   Output.P;
    458460   Output.P ("end Gela.LARL_Parsers.Data;");
     
    460462   Output.P;
    461463   Output.P ("package body Gela.LARL_Parsers.Data is");
    462    Output.P ("   use Gela.Grammars.LR_Parsers;");
     464   Output.P ("   use Anagram.Grammars.LR_Parsers;");
    463465   Output.P;
    464466
     
    468470   Output.P ("end Gela.LARL_Parsers.Data;");
    469471   Output.P;
    470    Output.P ("with Gela.Grammars;");
     472   Output.P ("with Anagram.Grammars;");
    471473   Output.P ("with Gela.LARL_Parsers_Nodes;");
    472474   Output.N ("private ");
     
    479481   for Piece_Index in 0 .. (Plain.Last_Production - 1) / Piece_Length loop
    480482      declare
    481          From  : constant Gela.Grammars.Production_Index :=
     483         From  : constant Anagram.Grammars.Production_Index :=
    482484           Piece_Index * Piece_Length + 1;
    483485      begin
     
    495497   for Piece_Index in 0 .. (Plain.Last_Production - 1) / Piece_Length loop
    496498      declare
    497          From  : constant Gela.Grammars.Production_Index :=
     499         From  : constant Anagram.Grammars.Production_Index :=
    498500           Piece_Index * Piece_Length + 1;
    499          To    : constant Gela.Grammars.Production_Index :=
    500            Gela.Grammars.Production_Index'Min
     501         To    : constant Anagram.Grammars.Production_Index :=
     502           Anagram.Grammars.Production_Index'Min
    501503             (Plain.Last_Production, (Piece_Index + 1) * Piece_Length);
    502504      begin
     
    525527   Ada.Text_IO.Put_Line (Piece.Text.To_UTF_8_String);
    526528
    527    Gela.Grammars_Debug.Print_Conflicts (AG, Table.all);
     529   Anagram.Grammars_Debug.Print_Conflicts (AG, Table.all);
    528530
    529531   if Ada.Command_Line.Argument_Count > 1 then
    530       Gela.Grammars_Debug.Print (G);
     532      Anagram.Grammars_Debug.Print (G);
    531533   end if;
    532534end YACC_Driver;
  • trunk/ada-2012/tools/tester/gela-test_driver2.adb

    r415 r537  
    1717with Gela.Test_Cases;
    1818with Gela.Test_Iterators.Dir2;
     19--  We don't use Dir2 now, but we would like to compile it to avoid errors.
     20pragma Unreferenced (Gela.Test_Iterators.Dir2);
    1921with Gela.Test_Iterators.ACATS;
    2022with Gela.Test_Iterators.Append;
     
    146148   declare
    147149      use type Gela.Test_Iterators.Append.Iterator;
    148       Dirs  : constant Gela.Test_Iterators.Iterator'Class :=
    149         Gela.Test_Iterators.Dir2.Create
    150           (Tests & "/grammars", Build & "/tests/grammars");
    151150      Lexer : constant Gela.Test_Iterators.Iterator'Class :=
    152151        Gela.Test_Iterators.ACATS.Create
     
    180179           ACATS     => ACATS_Dir);
    181180      Iterator : Gela.Test_Iterators.Append.Iterator :=
    182         Dirs + Lexer + Parser + Def_Name + ASIS2XML + Run_Compiler;
     181        Lexer + Parser + Def_Name + ASIS2XML + Run_Compiler;
    183182   begin
    184183      Iterator.Start;
Note: See TracChangeset for help on using the changeset viewer.