Subversion Repositories openrisc

------------------------------------------------------------------------------

--                                                                          --

--                         GNAT COMPILER COMPONENTS                         --

--                                                                          --

--                             P R J . C O N F                             --

--                                                                          --

--                                 B o d y                                  --

--                                                                          --

--            Copyright (C) 2006-2012, Free Software Foundation, Inc.       --

--                                                                          --

-- GNAT is free software;  you can  redistribute it  and/or modify it under --

-- terms of the  GNU General Public License as published  by the Free Soft- --

-- ware  Foundation;  either version 3,  or (at your option) any later ver- --

-- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --

-- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --

-- or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License --

-- for  more details.  You should have  received  a copy of the GNU General --

-- Public License  distributed with GNAT; see file COPYING3.  If not, go to --

-- http://www.gnu.org/licenses for a complete copy of the license.          --

--                                                                          --

-- GNAT was originally developed  by the GNAT team at  New York University. --

-- Extensive contributions were provided by Ada Core Technologies Inc.      --

--                                                                          --

------------------------------------------------------------------------------

with Hostparm;

with Makeutl;  use Makeutl;

with MLib.Tgt;

with Opt;      use Opt;

with Output;   use Output;

with Prj.Env;

with Prj.Err;

with Prj.Part;

with Prj.PP;

with Prj.Proc; use Prj.Proc;

with Prj.Tree; use Prj.Tree;

with Prj.Util; use Prj.Util;

with Prj;      use Prj;

with Snames;   use Snames;

with Ada.Directories; use Ada.Directories;

with Ada.Exceptions;  use Ada.Exceptions;

with GNAT.Case_Util; use GNAT.Case_Util;

with GNAT.HTable;    use GNAT.HTable;

package body Prj.Conf is

   Auto_Cgpr : constant String := "auto.cgpr";

   Default_Name : constant String := "default.cgpr";

   --  Default configuration file that will be used if found

   Config_Project_Env_Var : constant String := "GPR_CONFIG";

   --  Name of the environment variable that provides the name of the

   --  configuration file to use.

   Gprconfig_Name : constant String := "gprconfig";

   package RTS_Languages is new GNAT.HTable.Simple_HTable

     (Header_Num => Prj.Header_Num,

      Element    => Name_Id,

      No_Element => No_Name,

      Key        => Name_Id,

      Hash       => Prj.Hash,

      Equal      => "=");

   --  Stores the runtime names for the various languages. This is in general

   --  set from a --RTS command line option.

   -----------------------

   -- Local_Subprograms --

   -----------------------

   procedure Add_Attributes

     (Project_Tree : Project_Tree_Ref;

      Conf_Decl    : Declarations;

      User_Decl    : in out Declarations);

   --  Process the attributes in the config declarations.

   --  For single string values, if the attribute is not declared in the user

   --  declarations, declare it with the value in the config declarations.

   --  For string list values, prepend the value in the user declarations with

   --  the value in the config declarations.

   function Check_Target

     (Config_File        : Prj.Project_Id;

      Autoconf_Specified : Boolean;

      Project_Tree       : Prj.Project_Tree_Ref;

      Target             : String := "") return Boolean;

   --  Check that the config file's target matches Target.

   --  Target should be set to the empty string when the user did not specify

   --  a target. If the target in the configuration file is invalid, this

   --  function will raise Invalid_Config with an appropriate message.

   --  Autoconf_Specified should be set to True if the user has used

   --  autoconf.

   function Locate_Config_File (Name : String) return String_Access;

   --  Search for Name in the config files directory. Return full path if

   --  found, or null otherwise.

   procedure Raise_Invalid_Config (Msg : String);

   pragma No_Return (Raise_Invalid_Config);

   --  Raises exception Invalid_Config with given message

   procedure Apply_Config_File

     (Config_File  : Prj.Project_Id;

      Project_Tree : Prj.Project_Tree_Ref);

   --  Apply the configuration file settings to all the projects in the

   --  project tree. The Project_Tree must have been parsed first, and

   --  processed through the first phase so that all its projects are known.

   --

   --  Currently, this will add new attributes and packages in the various

   --  projects, so that when the second phase of the processing is performed

   --  these attributes are automatically taken into account.

   --------------------

   -- Add_Attributes --

   --------------------

   procedure Add_Attributes

     (Project_Tree : Project_Tree_Ref;

      Conf_Decl    : Declarations;

      User_Decl    : in out Declarations)

   is

      Shared : constant Shared_Project_Tree_Data_Access := Project_Tree.Shared;

      Conf_Attr_Id       : Variable_Id;

      Conf_Attr          : Variable;

      Conf_Array_Id      : Array_Id;

      Conf_Array         : Array_Data;

      Conf_Array_Elem_Id : Array_Element_Id;

      Conf_Array_Elem    : Array_Element;

      Conf_List          : String_List_Id;

      Conf_List_Elem     : String_Element;

      User_Attr_Id       : Variable_Id;

      User_Attr          : Variable;

      User_Array_Id      : Array_Id;

      User_Array         : Array_Data;

      User_Array_Elem_Id : Array_Element_Id;

      User_Array_Elem    : Array_Element;

   begin

      Conf_Attr_Id := Conf_Decl.Attributes;

      User_Attr_Id := User_Decl.Attributes;

      while Conf_Attr_Id /= No_Variable loop

         Conf_Attr := Shared.Variable_Elements.Table (Conf_Attr_Id);

         User_Attr := Shared.Variable_Elements.Table (User_Attr_Id);

         if not Conf_Attr.Value.Default then

            if User_Attr.Value.Default then

               --  No attribute declared in user project file: just copy the

               --  value of the configuration attribute.

               User_Attr.Value := Conf_Attr.Value;

               Shared.Variable_Elements.Table (User_Attr_Id) := User_Attr;

            elsif User_Attr.Value.Kind = List

              and then Conf_Attr.Value.Values /= Nil_String

            then

               --  List attribute declared in both the user project and the

               --  configuration project: prepend the user list with the

               --  configuration list.

               declare

                  User_List : constant String_List_Id :=

                                User_Attr.Value.Values;

                  Conf_List : String_List_Id := Conf_Attr.Value.Values;

                  Conf_Elem : String_Element;

                  New_List  : String_List_Id;

                  New_Elem  : String_Element;

               begin

                  --  Create new list

                  String_Element_Table.Increment_Last

                    (Shared.String_Elements);

                  New_List :=

                    String_Element_Table.Last (Shared.String_Elements);

                  --  Value of attribute is new list

                  User_Attr.Value.Values := New_List;

                  Shared.Variable_Elements.Table (User_Attr_Id) := User_Attr;

                  loop

                     --  Get each element of configuration list

                     Conf_Elem := Shared.String_Elements.Table (Conf_List);

                     New_Elem  := Conf_Elem;

                     Conf_List := Conf_Elem.Next;

                     if Conf_List = Nil_String then

                        --  If it is the last element in the list, connect to

                        --  first element of user list, and we are done.

                        New_Elem.Next := User_List;

                        Shared.String_Elements.Table (New_List) := New_Elem;

                        exit;

                     else

                        --  If it is not the last element in the list, add to

                        --  new list.

                        String_Element_Table.Increment_Last

                          (Shared.String_Elements);

                        New_Elem.Next :=

                          String_Element_Table.Last (Shared.String_Elements);

                        Shared.String_Elements.Table (New_List) := New_Elem;

                        New_List := New_Elem.Next;

                     end if;

                  end loop;

               end;

            end if;

         end if;

         Conf_Attr_Id := Conf_Attr.Next;

         User_Attr_Id := User_Attr.Next;

      end loop;

      Conf_Array_Id := Conf_Decl.Arrays;

      while Conf_Array_Id /= No_Array loop

         Conf_Array := Shared.Arrays.Table (Conf_Array_Id);

         User_Array_Id := User_Decl.Arrays;

         while User_Array_Id /= No_Array loop

            User_Array := Shared.Arrays.Table (User_Array_Id);

            exit when User_Array.Name = Conf_Array.Name;

            User_Array_Id := User_Array.Next;

         end loop;

         --  If this associative array does not exist in the user project file,

         --  do a shallow copy of the full associative array.

         if User_Array_Id = No_Array then

            Array_Table.Increment_Last (Shared.Arrays);

            User_Array := Conf_Array;

            User_Array.Next := User_Decl.Arrays;

            User_Decl.Arrays := Array_Table.Last (Shared.Arrays);

            Shared.Arrays.Table (User_Decl.Arrays) := User_Array;

         --  Otherwise, check each array element

         else

            Conf_Array_Elem_Id := Conf_Array.Value;

            while Conf_Array_Elem_Id /= No_Array_Element loop

               Conf_Array_Elem :=

                 Shared.Array_Elements.Table (Conf_Array_Elem_Id);

               User_Array_Elem_Id := User_Array.Value;

               while User_Array_Elem_Id /= No_Array_Element loop

                  User_Array_Elem :=

                    Shared.Array_Elements.Table (User_Array_Elem_Id);

                  exit when User_Array_Elem.Index = Conf_Array_Elem.Index;

                  User_Array_Elem_Id := User_Array_Elem.Next;

               end loop;

               --  If the array element doesn't exist in the user array, insert

               --  a shallow copy of the conf array element in the user array.

               if User_Array_Elem_Id = No_Array_Element then

                  Array_Element_Table.Increment_Last (Shared.Array_Elements);

                  User_Array_Elem := Conf_Array_Elem;

                  User_Array_Elem.Next := User_Array.Value;

                  User_Array.Value :=

                    Array_Element_Table.Last (Shared.Array_Elements);

                  Shared.Array_Elements.Table (User_Array.Value) :=

                    User_Array_Elem;

                  Shared.Arrays.Table (User_Array_Id) := User_Array;

               --  Otherwise, if the value is a string list, prepend the conf

               --  array element value to the array element.

               elsif Conf_Array_Elem.Value.Kind = List then

                  Conf_List := Conf_Array_Elem.Value.Values;

                  if Conf_List /= Nil_String then

                     declare

                        Link     : constant String_List_Id :=

                                     User_Array_Elem.Value.Values;

                        Previous : String_List_Id := Nil_String;

                        Next     : String_List_Id;

                     begin

                        loop

                           Conf_List_Elem :=

                             Shared.String_Elements.Table (Conf_List);

                           String_Element_Table.Increment_Last

                             (Shared.String_Elements);

                           Next :=

                             String_Element_Table.Last

                               (Shared.String_Elements);

                           Shared.String_Elements.Table (Next) :=

                             Conf_List_Elem;

                           if Previous = Nil_String then

                              User_Array_Elem.Value.Values := Next;

                              Shared.Array_Elements.Table

                                (User_Array_Elem_Id) := User_Array_Elem;

                           else

                              Shared.String_Elements.Table

                                (Previous).Next := Next;

                           end if;

                           Previous := Next;

                           Conf_List := Conf_List_Elem.Next;

                           if Conf_List = Nil_String then

                              Shared.String_Elements.Table (Previous).Next :=

                                Link;

                              exit;

                           end if;

                        end loop;

                     end;

                  end if;

               end if;

               Conf_Array_Elem_Id := Conf_Array_Elem.Next;

            end loop;

         end if;

         Conf_Array_Id := Conf_Array.Next;

      end loop;

   end Add_Attributes;

   ------------------------------------

   -- Add_Default_GNAT_Naming_Scheme --

   ------------------------------------

   procedure Add_Default_GNAT_Naming_Scheme

     (Config_File  : in out Project_Node_Id;

      Project_Tree : Project_Node_Tree_Ref)

   is

      procedure Create_Attribute

        (Name  : Name_Id;

         Value : String;

         Index : String := "";

         Pkg   : Project_Node_Id := Empty_Node);

      ----------------------

      -- Create_Attribute --

      ----------------------

      procedure Create_Attribute

        (Name  : Name_Id;

         Value : String;

         Index : String := "";

         Pkg   : Project_Node_Id := Empty_Node)

      is

         Attr : Project_Node_Id;

         pragma Unreferenced (Attr);

         Expr   : Name_Id         := No_Name;

         Val    : Name_Id         := No_Name;

         Parent : Project_Node_Id := Config_File;

      begin

         if Index /= "" then

            Name_Len := Index'Length;

            Name_Buffer (1 .. Name_Len) := Index;

            Val := Name_Find;

         end if;

         if Pkg /= Empty_Node then

            Parent := Pkg;

         end if;

         Name_Len := Value'Length;

         Name_Buffer (1 .. Name_Len) := Value;

         Expr := Name_Find;

         Attr := Create_Attribute

           (Tree       => Project_Tree,

            Prj_Or_Pkg => Parent,

            Name       => Name,

            Index_Name => Val,

            Kind       => Prj.Single,

            Value      => Create_Literal_String (Expr, Project_Tree));

      end Create_Attribute;

      --  Local variables

      Name     : Name_Id;

      Naming   : Project_Node_Id;

      Compiler : Project_Node_Id;

   --  Start of processing for Add_Default_GNAT_Naming_Scheme

   begin

      if Config_File = Empty_Node then

         --  Create a dummy config file is none was found

         Name_Len := Auto_Cgpr'Length;

         Name_Buffer (1 .. Name_Len) := Auto_Cgpr;

         Name := Name_Find;

         --  An invalid project name to avoid conflicts with user-created ones

         Name_Len := 5;

         Name_Buffer (1 .. Name_Len) := "_auto";

         Config_File :=

           Create_Project

             (In_Tree        => Project_Tree,

              Name           => Name_Find,

              Full_Path      => Path_Name_Type (Name),

              Is_Config_File => True);

         --  Setup library support

         case MLib.Tgt.Support_For_Libraries is

            when None =>

               null;

            when Static_Only =>

               Create_Attribute (Name_Library_Support, "static_only");

            when Full =>

               Create_Attribute (Name_Library_Support, "full");

         end case;

         if MLib.Tgt.Standalone_Library_Auto_Init_Is_Supported then

            Create_Attribute (Name_Library_Auto_Init_Supported, "true");

         else

            Create_Attribute (Name_Library_Auto_Init_Supported, "false");

         end if;

         --  Setup Ada support (Ada is the default language here, since this

         --  is only called when no config file existed initially, ie for

         --  gnatmake).

         Create_Attribute (Name_Default_Language, "ada");

         Compiler := Create_Package (Project_Tree, Config_File, "compiler");

         Create_Attribute

           (Name_Driver, "gcc", "ada", Pkg => Compiler);

         Create_Attribute

           (Name_Language_Kind, "unit_based", "ada", Pkg => Compiler);

         Create_Attribute

           (Name_Dependency_Kind, "ALI_File", "ada", Pkg => Compiler);

         Naming := Create_Package (Project_Tree, Config_File, "naming");

         Create_Attribute (Name_Spec_Suffix, ".ads", "ada",     Pkg => Naming);

         Create_Attribute (Name_Separate_Suffix, ".adb", "ada", Pkg => Naming);

         Create_Attribute (Name_Body_Suffix, ".adb", "ada",     Pkg => Naming);

         Create_Attribute (Name_Dot_Replacement, "-",           Pkg => Naming);

         Create_Attribute (Name_Casing,          "lowercase",   Pkg => Naming);

         if Current_Verbosity = High then

            Write_Line ("Automatically generated (in-memory) config file");

            Prj.PP.Pretty_Print

              (Project                => Config_File,

               In_Tree                => Project_Tree,

               Backward_Compatibility => False);

         end if;

      end if;

   end Add_Default_GNAT_Naming_Scheme;

   -----------------------

   -- Apply_Config_File --

   -----------------------

   procedure Apply_Config_File

     (Config_File  : Prj.Project_Id;

      Project_Tree : Prj.Project_Tree_Ref)

   is

      Shared : constant Shared_Project_Tree_Data_Access := Project_Tree.Shared;

      Conf_Decl    : constant Declarations := Config_File.Decl;

      Conf_Pack_Id : Package_Id;

      Conf_Pack    : Package_Element;

      User_Decl    : Declarations;

      User_Pack_Id : Package_Id;

      User_Pack    : Package_Element;

      Proj         : Project_List;

   begin

      Debug_Output ("Applying config file to a project tree");

      Proj := Project_Tree.Projects;

      while Proj /= null loop

         if Proj.Project /= Config_File then

            User_Decl := Proj.Project.Decl;

            Add_Attributes

              (Project_Tree      => Project_Tree,

               Conf_Decl         => Conf_Decl,

               User_Decl         => User_Decl);

            Conf_Pack_Id := Conf_Decl.Packages;

            while Conf_Pack_Id /= No_Package loop

               Conf_Pack := Shared.Packages.Table (Conf_Pack_Id);

               User_Pack_Id := User_Decl.Packages;

               while User_Pack_Id /= No_Package loop

                  User_Pack := Shared.Packages.Table (User_Pack_Id);

                  exit when User_Pack.Name = Conf_Pack.Name;

                  User_Pack_Id := User_Pack.Next;

               end loop;

               if User_Pack_Id = No_Package then

                  Package_Table.Increment_Last (Shared.Packages);

                  User_Pack := Conf_Pack;

                  User_Pack.Next := User_Decl.Packages;

                  User_Decl.Packages := Package_Table.Last (Shared.Packages);

                  Shared.Packages.Table (User_Decl.Packages) := User_Pack;

               else

                  Add_Attributes

                    (Project_Tree => Project_Tree,

                     Conf_Decl    => Conf_Pack.Decl,

                     User_Decl    => Shared.Packages.Table

                                       (User_Pack_Id).Decl);

               end if;

               Conf_Pack_Id := Conf_Pack.Next;

            end loop;

            Proj.Project.Decl := User_Decl;

            --  For aggregate projects, we need to apply the config to all

            --  their aggregated trees as well.

            if Proj.Project.Qualifier in Aggregate_Project then

               declare

                  List : Aggregated_Project_List;

               begin

                  List := Proj.Project.Aggregated_Projects;

                  while List /= null loop

                     Debug_Output

                       ("Recursively apply config to aggregated tree",

                        List.Project.Name);

                     Apply_Config_File

                       (Config_File, Project_Tree => List.Tree);

                     List := List.Next;

                  end loop;

               end;

            end if;

         end if;

         Proj := Proj.Next;

      end loop;

   end Apply_Config_File;

   ------------------

   -- Check_Target --

   ------------------

   function Check_Target

     (Config_File        : Project_Id;

      Autoconf_Specified : Boolean;

      Project_Tree       : Prj.Project_Tree_Ref;

      Target             : String := "") return Boolean

   is

      Shared   : constant Shared_Project_Tree_Data_Access :=

                   Project_Tree.Shared;

      Variable : constant Variable_Value :=

                   Value_Of

                     (Name_Target, Config_File.Decl.Attributes, Shared);

      Tgt_Name : Name_Id := No_Name;

      OK       : Boolean;

   begin

      if Variable /= Nil_Variable_Value and then not Variable.Default then

         Tgt_Name := Variable.Value;

      end if;

      if Target = "" then

         OK := not Autoconf_Specified or else Tgt_Name = No_Name;

      else

         OK := Tgt_Name /= No_Name

                 and then Target = Get_Name_String (Tgt_Name);

      end if;

      if not OK then

         if Autoconf_Specified then

            if Verbose_Mode then

               Write_Line ("inconsistent targets, performing autoconf");

            end if;

            return False;

         else

            if Tgt_Name /= No_Name then

               Raise_Invalid_Config

                 ("invalid target name """

                  & Get_Name_String (Tgt_Name) & """ in configuration");

            else

               Raise_Invalid_Config

                 ("no target specified in configuration file");

            end if;

         end if;

      end if;

      return True;

   end Check_Target;

   --------------------------------------

   -- Get_Or_Create_Configuration_File --

   --------------------------------------

   procedure Get_Or_Create_Configuration_File

     (Project                    : Project_Id;

      Project_Tree               : Project_Tree_Ref;

      Project_Node_Tree          : Prj.Tree.Project_Node_Tree_Ref;

      Env                        : in out Prj.Tree.Environment;

      Allow_Automatic_Generation : Boolean;

      Config_File_Name           : String := "";

      Autoconf_Specified         : Boolean;

      Target_Name                : String := "";

      Normalized_Hostname        : String;

      Packages_To_Check          : String_List_Access := null;

      Config                     : out Prj.Project_Id;

      Config_File_Path           : out String_Access;

      Automatically_Generated    : out Boolean;

      On_Load_Config             : Config_File_Hook := null)

   is

      Shared : constant Shared_Project_Tree_Data_Access := Project_Tree.Shared;

      At_Least_One_Compiler_Command : Boolean := False;

      --  Set to True if at least one attribute Ide'Compiler_Command is

      --  specified for one language of the system.

      function Default_File_Name return String;

      --  Return the name of the default config file that should be tested

      procedure Do_Autoconf;

      --  Generate a new config file through gprconfig. In case of error, this

      --  raises the Invalid_Config exception with an appropriate message

      function Get_Config_Switches return Argument_List_Access;

      --  Return the --config switches to use for gprconfig

      function Might_Have_Sources (Project : Project_Id) return Boolean;

      --  True if the specified project might have sources (ie the user has not

      --  explicitly specified it. We haven't checked the file system, nor do

      --  we need to at this stage.

      -----------------------

      -- Default_File_Name --

      -----------------------

      function Default_File_Name return String is

         Ada_RTS : constant String := Runtime_Name_For (Name_Ada);

         Tmp     : String_Access;

      begin

         if Target_Name /= "" then

            if Ada_RTS /= "" then

               return Target_Name & '-' & Ada_RTS

                 & Config_Project_File_Extension;

            else

               return Target_Name & Config_Project_File_Extension;

            end if;

         elsif Ada_RTS /= "" then

            return Ada_RTS & Config_Project_File_Extension;

         else

            Tmp := Getenv (Config_Project_Env_Var);

            declare

               T : constant String := Tmp.all;

            begin

               Free (Tmp);

               if T'Length = 0 then

                  return Default_Name;

               else

                  return T;

               end if;

            end;

         end if;

      end Default_File_Name;

      ------------------------

      -- Might_Have_Sources --

      ------------------------

      function Might_Have_Sources (Project : Project_Id) return Boolean is

         Variable : Variable_Value;

      begin

         Variable :=

           Value_Of

             (Name_Source_Dirs,

              Project.Decl.Attributes,

              Shared);

         if Variable = Nil_Variable_Value

           or else Variable.Default

           or else Variable.Values /= Nil_String

         then

            Variable :=

              Value_Of

                (Name_Source_Files,

                 Project.Decl.Attributes,

                 Shared);

            return Variable = Nil_Variable_Value

              or else Variable.Default

              or else Variable.Values /= Nil_String;

         else

            return False;

         end if;

      end Might_Have_Sources;

      -------------------------

      -- Get_Config_Switches --

      -------------------------

      function Get_Config_Switches return Argument_List_Access is

         package Language_Htable is new GNAT.HTable.Simple_HTable

           (Header_Num => Prj.Header_Num,

            Element    => Name_Id,

            No_Element => No_Name,

            Key        => Name_Id,

            Hash       => Prj.Hash,

            Equal      => "=");

         --  Hash table to keep the languages used in the project tree

         IDE : constant Package_Id :=

                 Value_Of (Name_Ide, Project.Decl.Packages, Shared);

         procedure Add_Config_Switches_For_Project

           (Project    : Project_Id;

            Tree       : Project_Tree_Ref;

            With_State : in out Integer);

         --  Add all --config switches for this project. This is also called

         --  for aggregate projects.

         -------------------------------------

         -- Add_Config_Switches_For_Project --

         -------------------------------------

         procedure Add_Config_Switches_For_Project

           (Project    : Project_Id;

            Tree       : Project_Tree_Ref;

            With_State : in out Integer)

         is

            pragma Unreferenced (With_State);

            Shared : constant Shared_Project_Tree_Data_Access := Tree.Shared;

            Variable      : Variable_Value;

            Check_Default : Boolean;

            Lang          : Name_Id;

            List          : String_List_Id;

            Elem          : String_Element;

         begin

            if Might_Have_Sources (Project) then

               Variable :=

                 Value_Of (Name_Languages, Project.Decl.Attributes, Shared);

               if Variable = Nil_Variable_Value or else Variable.Default then

                  --  Languages is not declared. If it is not an extending

                  --  project, or if it extends a project with no Languages,

                  --  check for Default_Language.

                  Check_Default := Project.Extends = No_Project;

                  if not Check_Default then

                     Variable :=

                       Value_Of

                         (Name_Languages,

                          Project.Extends.Decl.Attributes,

                          Shared);

                     Check_Default :=

                       Variable /= Nil_Variable_Value

                         and then Variable.Values = Nil_String;

                  end if;

                  if Check_Default then

                     Variable :=

                       Value_Of

                         (Name_Default_Language,

                          Project.Decl.Attributes,

                          Shared);

                     if Variable /= Nil_Variable_Value

                       and then not Variable.Default

                     then

                        Get_Name_String (Variable.Value);

                        To_Lower (Name_Buffer (1 .. Name_Len));

                        Lang := Name_Find;

                        Language_Htable.Set (Lang, Lang);

                     --  If no default language is declared, default to Ada