OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [tags/] [gnu-src/] [gcc-4.5.1/] [gcc-4.5.1-or32-1.0rc1/] [gcc/] [testsuite/] [ada/] [acats/] [tests/] [cxb/] [cxb5002.a] - Diff between revs 294 and 338

Only display areas with differences | Details | Blame | View Log

Rev 294 Rev 338
-- CXB5002.A
-- CXB5002.A
--
--
--                             Grant of Unlimited Rights
--                             Grant of Unlimited Rights
--
--
--     Under contracts F33600-87-D-0337, F33600-84-D-0280, MDA903-79-C-0687,
--     Under contracts F33600-87-D-0337, F33600-84-D-0280, MDA903-79-C-0687,
--     F08630-91-C-0015, and DCA100-97-D-0025, the U.S. Government obtained
--     F08630-91-C-0015, and DCA100-97-D-0025, the U.S. Government obtained
--     unlimited rights in the software and documentation contained herein.
--     unlimited rights in the software and documentation contained herein.
--     Unlimited rights are defined in DFAR 252.227-7013(a)(19).  By making
--     Unlimited rights are defined in DFAR 252.227-7013(a)(19).  By making
--     this public release, the Government intends to confer upon all
--     this public release, the Government intends to confer upon all
--     recipients unlimited rights  equal to those held by the Government.
--     recipients unlimited rights  equal to those held by the Government.
--     These rights include rights to use, duplicate, release or disclose the
--     These rights include rights to use, duplicate, release or disclose the
--     released technical data and computer software in whole or in part, in
--     released technical data and computer software in whole or in part, in
--     any manner and for any purpose whatsoever, and to have or permit others
--     any manner and for any purpose whatsoever, and to have or permit others
--     to do so.
--     to do so.
--
--
--                                    DISCLAIMER
--                                    DISCLAIMER
--
--
--     ALL MATERIALS OR INFORMATION HEREIN RELEASED, MADE AVAILABLE OR
--     ALL MATERIALS OR INFORMATION HEREIN RELEASED, MADE AVAILABLE OR
--     DISCLOSED ARE AS IS.  THE GOVERNMENT MAKES NO EXPRESS OR IMPLIED
--     DISCLOSED ARE AS IS.  THE GOVERNMENT MAKES NO EXPRESS OR IMPLIED
--     WARRANTY AS TO ANY MATTER WHATSOEVER, INCLUDING THE CONDITIONS OF THE
--     WARRANTY AS TO ANY MATTER WHATSOEVER, INCLUDING THE CONDITIONS OF THE
--     SOFTWARE, DOCUMENTATION OR OTHER INFORMATION RELEASED, MADE AVAILABLE
--     SOFTWARE, DOCUMENTATION OR OTHER INFORMATION RELEASED, MADE AVAILABLE
--     OR DISCLOSED, OR THE OWNERSHIP, MERCHANTABILITY, OR FITNESS FOR A
--     OR DISCLOSED, OR THE OWNERSHIP, MERCHANTABILITY, OR FITNESS FOR A
--     PARTICULAR PURPOSE OF SAID MATERIAL.
--     PARTICULAR PURPOSE OF SAID MATERIAL.
--*
--*
--
--
-- OBJECTIVE:
-- OBJECTIVE:
--      Check that the Function To_Fortran with a Character parameter will
--      Check that the Function To_Fortran with a Character parameter will
--      return the corresponding Fortran Character_Set value.
--      return the corresponding Fortran Character_Set value.
--
--
--      Check that the Function To_Ada with a Character_Set parameter will
--      Check that the Function To_Ada with a Character_Set parameter will
--      return the corresponding Ada Character value.
--      return the corresponding Ada Character value.
--
--
--      Check that the Function To_Fortran with a String parameter will
--      Check that the Function To_Fortran with a String parameter will
--      return the corresponding Fortran_Character value.
--      return the corresponding Fortran_Character value.
--
--
--      Check that the Function To_Ada with a Fortran_Character parameter
--      Check that the Function To_Ada with a Fortran_Character parameter
--      will return the corresponding Ada String value.
--      will return the corresponding Ada String value.
--
--
-- TEST DESCRIPTION:
-- TEST DESCRIPTION:
--      This test checks that the functions To_Fortran and To_Ada produce
--      This test checks that the functions To_Fortran and To_Ada produce
--      the correct results, based on a variety of parameter input values.
--      the correct results, based on a variety of parameter input values.
--
--
--      In the first series of subtests, the results of the function
--      In the first series of subtests, the results of the function
--      To_Fortran are compared against expected Character_Set type results.
--      To_Fortran are compared against expected Character_Set type results.
--      In the second series of subtests, the results of the function To_Ada
--      In the second series of subtests, the results of the function To_Ada
--      are compared against expected String type results, and the length of
--      are compared against expected String type results, and the length of
--      the String result is also verified against the Fortran_Character type
--      the String result is also verified against the Fortran_Character type
--      parameter.
--      parameter.
--
--
--      This test uses Fixed, Bounded, and Unbounded_Strings in combination
--      This test uses Fixed, Bounded, and Unbounded_Strings in combination
--      with the functions under validation.
--      with the functions under validation.
--
--
--      This test assumes that the following characters are all included
--      This test assumes that the following characters are all included
--      in the implementation defined type Interfaces.Fortran.Character_Set:
--      in the implementation defined type Interfaces.Fortran.Character_Set:
--      ' ', 'a'..'z', 'A'..'Z', '1'..'9', '-', '_', '$', '#', and '*'.
--      ' ', 'a'..'z', 'A'..'Z', '1'..'9', '-', '_', '$', '#', and '*'.
--
--
-- APPLICABILITY CRITERIA:
-- APPLICABILITY CRITERIA:
--      This test is applicable to all implementations that provide
--      This test is applicable to all implementations that provide
--      package Interfaces.Fortran.  If an implementation provides
--      package Interfaces.Fortran.  If an implementation provides
--      package Interfaces.Fortran, this test must compile, execute, and
--      package Interfaces.Fortran, this test must compile, execute, and
--      report "PASSED".
--      report "PASSED".
--
--
--      This test does not apply to an implementation in which the Fortran
--      This test does not apply to an implementation in which the Fortran
--      character set ranges are not contiguous (e.g., EBCDIC).
--      character set ranges are not contiguous (e.g., EBCDIC).
--
--
--
--
--
--
-- CHANGE HISTORY:
-- CHANGE HISTORY:
--      11 Mar 96   SAIC    Initial release for 2.1.
--      11 Mar 96   SAIC    Initial release for 2.1.
--      10 Jun 96   SAIC    Incorporated reviewer comments for ACVC 2.1.
--      10 Jun 96   SAIC    Incorporated reviewer comments for ACVC 2.1.
--      27 Oct 96   SAIC    Incorporated reviewer comments.
--      27 Oct 96   SAIC    Incorporated reviewer comments.
--
--
--!
--!
with Ada.Characters.Latin_1;
with Ada.Characters.Latin_1;
with Ada.Exceptions;
with Ada.Exceptions;
with Ada.Strings.Bounded;
with Ada.Strings.Bounded;
with Ada.Strings.Unbounded;
with Ada.Strings.Unbounded;
with Ada.Unchecked_Conversion;
with Ada.Unchecked_Conversion;
with Interfaces.Fortran;                                      -- N/A => ERROR
with Interfaces.Fortran;                                      -- N/A => ERROR
with Report;
with Report;
procedure CXB5002 is
procedure CXB5002 is
begin
begin
   Report.Test ("CXB5002", "Check that functions To_Fortran and To_Ada " &
   Report.Test ("CXB5002", "Check that functions To_Fortran and To_Ada " &
                           "produce correct results");
                           "produce correct results");
   Test_Block:
   Test_Block:
   declare
   declare
      package ACL renames Ada.Characters.Latin_1;
      package ACL renames Ada.Characters.Latin_1;
      package Bnd is new Ada.Strings.Bounded.Generic_Bounded_Length(10);
      package Bnd is new Ada.Strings.Bounded.Generic_Bounded_Length(10);
      package Unb renames Ada.Strings.Unbounded;
      package Unb renames Ada.Strings.Unbounded;
      use Bnd, Unb;
      use Bnd, Unb;
      use Interfaces.Fortran;
      use Interfaces.Fortran;
      use Ada.Exceptions;
      use Ada.Exceptions;
      Null_Fortran_Character  : constant Fortran_Character := "";
      Null_Fortran_Character  : constant Fortran_Character := "";
      Fortran_Character_1     : Fortran_Character(1..1)    := " ";
      Fortran_Character_1     : Fortran_Character(1..1)    := " ";
      Fortran_Character_5     : Fortran_Character(1..5)    := "     ";
      Fortran_Character_5     : Fortran_Character(1..5)    := "     ";
      Fortran_Character_10    : Fortran_Character(1..10)   := "          ";
      Fortran_Character_10    : Fortran_Character(1..10)   := "          ";
      Fortran_Character_20    : Fortran_Character(1..20)   :=
      Fortran_Character_20    : Fortran_Character(1..20)   :=
                                  "                    ";
                                  "                    ";
      TC_Fortran_Character_1  : Fortran_Character(1..1)    := "A";
      TC_Fortran_Character_1  : Fortran_Character(1..1)    := "A";
      TC_Fortran_Character_5  : Fortran_Character(1..5)    := "ab*de";
      TC_Fortran_Character_5  : Fortran_Character(1..5)    := "ab*de";
      TC_Fortran_Character_10 : Fortran_Character(1..10)   := "$1a2b3C4D5";
      TC_Fortran_Character_10 : Fortran_Character(1..10)   := "$1a2b3C4D5";
      TC_Fortran_Character_20 : Fortran_Character(1..20)   :=
      TC_Fortran_Character_20 : Fortran_Character(1..20)   :=
                                  "1234-ABCD_6789#fghij";
                                  "1234-ABCD_6789#fghij";
      Bnd_String              : Bnd.Bounded_String   :=
      Bnd_String              : Bnd.Bounded_String   :=
                                  Bnd.To_Bounded_String("          ");
                                  Bnd.To_Bounded_String("          ");
      TC_Bnd_String           : Bounded_String       :=
      TC_Bnd_String           : Bounded_String       :=
                                  To_Bounded_String("$1a2b3C4D5");
                                  To_Bounded_String("$1a2b3C4D5");
      Unb_String              : Unb.Unbounded_String :=
      Unb_String              : Unb.Unbounded_String :=
                                  Unb.To_Unbounded_String("     ");
                                  Unb.To_Unbounded_String("     ");
      TC_Unb_String           : Unbounded_String     :=
      TC_Unb_String           : Unbounded_String     :=
                                  To_Unbounded_String("ab*de");
                                  To_Unbounded_String("ab*de");
      String_1                : String(1..1)    := " ";
      String_1                : String(1..1)    := " ";
      String_5                : String(1..5)    := "     ";
      String_5                : String(1..5)    := "     ";
      String_10               : String(1..10)   := "          ";
      String_10               : String(1..10)   := "          ";
      String_20               : String(1..20)   := "                    ";
      String_20               : String(1..20)   := "                    ";
      TC_String_1             : String(1..1)    := "A";
      TC_String_1             : String(1..1)    := "A";
      TC_String_20            : String(1..20)   := "1234-ABCD_6789#fghij";
      TC_String_20            : String(1..20)   := "1234-ABCD_6789#fghij";
      Null_String             : constant String := "";
      Null_String             : constant String := "";
      Null_Character          : constant Character := ACL.Nul;
      Null_Character          : constant Character := ACL.Nul;
      Character_A             : constant Character := Character'Val(65);
      Character_A             : constant Character := Character'Val(65);
      Character_Z             : constant Character := Character'Val(90);
      Character_Z             : constant Character := Character'Val(90);
      TC_Character            : Character          := Character'First;
      TC_Character            : Character          := Character'First;
      Null_Character_Set      : Character_Set      := To_Fortran(ACL.Nul);
      Null_Character_Set      : Character_Set      := To_Fortran(ACL.Nul);
      TC_Character_Set,
      TC_Character_Set,
      TC_Low_Character_Set,
      TC_Low_Character_Set,
      TC_High_Character_Set   : Character_Set      := Character_Set'First;
      TC_High_Character_Set   : Character_Set      := Character_Set'First;
      -- The following procedure checks the results of function To_Ada.
      -- The following procedure checks the results of function To_Ada.
      procedure Check_Length (Str : in String;
      procedure Check_Length (Str : in String;
                              Ftn : in Fortran_Character;
                              Ftn : in Fortran_Character;
                              Num : in Natural) is
                              Num : in Natural) is
      begin
      begin
         if Str'Length /= Ftn'Length or
         if Str'Length /= Ftn'Length or
            Str'Length /= Num
            Str'Length /= Num
         then
         then
            Report.Failed("Incorrect result from Function To_Ada " &
            Report.Failed("Incorrect result from Function To_Ada " &
                          "with string length " & Integer'Image(Num));
                          "with string length " & Integer'Image(Num));
         end if;
         end if;
      end Check_Length;
      end Check_Length;
      -- To facilitate the conversion of Character-Character_Set data, the
      -- To facilitate the conversion of Character-Character_Set data, the
      -- following functions have been instantiated.
      -- following functions have been instantiated.
      function Character_to_Character_Set is
      function Character_to_Character_Set is
        new Ada.Unchecked_Conversion(Character, Character_Set);
        new Ada.Unchecked_Conversion(Character, Character_Set);
      function Character_Set_to_Character is
      function Character_Set_to_Character is
        new Ada.Unchecked_Conversion(Character_Set, Character);
        new Ada.Unchecked_Conversion(Character_Set, Character);
   begin
   begin
      -- Check that the Function To_Fortran with a Character parameter
      -- Check that the Function To_Fortran with a Character parameter
      -- will return the corresponding Fortran Character_Set value.
      -- will return the corresponding Fortran Character_Set value.
      for TC_Character in ACL.LC_A..ACL.LC_Z loop
      for TC_Character in ACL.LC_A..ACL.LC_Z loop
         if To_Fortran(Item => TC_Character) /=
         if To_Fortran(Item => TC_Character) /=
            Character_to_Character_Set(TC_Character)
            Character_to_Character_Set(TC_Character)
         then
         then
            Report.Failed("Incorrect result from To_Fortran with lower " &
            Report.Failed("Incorrect result from To_Fortran with lower " &
                          "case alphabetic character input");
                          "case alphabetic character input");
         end if;
         end if;
      end loop;
      end loop;
      for TC_Character in Character_A..Character_Z loop
      for TC_Character in Character_A..Character_Z loop
         if To_Fortran(TC_Character) /=
         if To_Fortran(TC_Character) /=
            Character_to_Character_Set(TC_Character)
            Character_to_Character_Set(TC_Character)
         then
         then
            Report.Failed("Incorrect result from To_Fortran with upper " &
            Report.Failed("Incorrect result from To_Fortran with upper " &
                          "case alphabetic character input");
                          "case alphabetic character input");
         end if;
         end if;
      end loop;
      end loop;
      if To_Fortran(Null_Character) /=
      if To_Fortran(Null_Character) /=
         Character_to_Character_Set(Null_Character)
         Character_to_Character_Set(Null_Character)
      then
      then
         Report.Failed
         Report.Failed
           ("Incorrect result from To_Fortran with null character input");
           ("Incorrect result from To_Fortran with null character input");
      end if;
      end if;
      -- Check that the Function To_Ada with a Character_Set parameter
      -- Check that the Function To_Ada with a Character_Set parameter
      -- will return the corresponding Ada Character value.
      -- will return the corresponding Ada Character value.
      TC_Low_Character_Set  := Character_to_Character_Set('a');
      TC_Low_Character_Set  := Character_to_Character_Set('a');
      TC_High_Character_Set := Character_to_Character_Set('z');
      TC_High_Character_Set := Character_to_Character_Set('z');
      for TC_Character_Set in TC_Low_Character_Set..TC_High_Character_Set loop
      for TC_Character_Set in TC_Low_Character_Set..TC_High_Character_Set loop
         if To_Ada(Item => TC_Character_Set) /=
         if To_Ada(Item => TC_Character_Set) /=
            Character_Set_to_Character(TC_Character_Set)
            Character_Set_to_Character(TC_Character_Set)
         then
         then
            Report.Failed("Incorrect result from To_Ada with lower case " &
            Report.Failed("Incorrect result from To_Ada with lower case " &
                          "alphabetic Character_Set input");
                          "alphabetic Character_Set input");
         end if;
         end if;
      end loop;
      end loop;
      TC_Low_Character_Set  := Character_to_Character_Set('A');
      TC_Low_Character_Set  := Character_to_Character_Set('A');
      TC_High_Character_Set := Character_to_Character_Set('Z');
      TC_High_Character_Set := Character_to_Character_Set('Z');
      for TC_Character_Set in TC_Low_Character_Set..TC_High_Character_Set loop
      for TC_Character_Set in TC_Low_Character_Set..TC_High_Character_Set loop
         if To_Ada(TC_Character_Set) /=
         if To_Ada(TC_Character_Set) /=
            Character_Set_to_Character(TC_Character_Set)
            Character_Set_to_Character(TC_Character_Set)
         then
         then
            Report.Failed("Incorrect result from To_Ada with upper case " &
            Report.Failed("Incorrect result from To_Ada with upper case " &
                          "alphabetic Character_Set input");
                          "alphabetic Character_Set input");
         end if;
         end if;
      end loop;
      end loop;
      if To_Ada(Character_to_Character_Set(Null_Character)) /=
      if To_Ada(Character_to_Character_Set(Null_Character)) /=
         Null_Character
         Null_Character
      then
      then
         Report.Failed("Incorrect result from To_Ada with a null " &
         Report.Failed("Incorrect result from To_Ada with a null " &
                       "Character_Set input");
                       "Character_Set input");
      end if;
      end if;
      -- Check that the Function To_Fortran with a String parameter
      -- Check that the Function To_Fortran with a String parameter
      -- will return the corresponding Fortran_Character value.
      -- will return the corresponding Fortran_Character value.
      -- Note: The type Fortran_Character is a character array type that
      -- Note: The type Fortran_Character is a character array type that
      --       corresponds to Ada type String.
      --       corresponds to Ada type String.
      Fortran_Character_1 := To_Fortran(Item => TC_String_1);
      Fortran_Character_1 := To_Fortran(Item => TC_String_1);
      if Fortran_Character_1 /= TC_Fortran_Character_1 then
      if Fortran_Character_1 /= TC_Fortran_Character_1 then
         Report.Failed("Incorrect result from procedure To_Fortran - 1");
         Report.Failed("Incorrect result from procedure To_Fortran - 1");
      end if;
      end if;
      Fortran_Character_5 := To_Fortran(To_String(TC_Unb_String));
      Fortran_Character_5 := To_Fortran(To_String(TC_Unb_String));
      if Fortran_Character_5 /= TC_Fortran_Character_5 then
      if Fortran_Character_5 /= TC_Fortran_Character_5 then
         Report.Failed("Incorrect result from procedure To_Fortran - 2");
         Report.Failed("Incorrect result from procedure To_Fortran - 2");
      end if;
      end if;
      Fortran_Character_10 := To_Fortran(To_String(TC_Bnd_String));
      Fortran_Character_10 := To_Fortran(To_String(TC_Bnd_String));
      if Fortran_Character_10 /= TC_Fortran_Character_10 then
      if Fortran_Character_10 /= TC_Fortran_Character_10 then
         Report.Failed("Incorrect result from procedure To_Fortran - 3");
         Report.Failed("Incorrect result from procedure To_Fortran - 3");
      end if;
      end if;
      Fortran_Character_20 := To_Fortran(Item => TC_String_20);
      Fortran_Character_20 := To_Fortran(Item => TC_String_20);
      if Fortran_Character_20 /= TC_Fortran_Character_20 then
      if Fortran_Character_20 /= TC_Fortran_Character_20 then
         Report.Failed("Incorrect result from procedure To_Fortran - 4");
         Report.Failed("Incorrect result from procedure To_Fortran - 4");
      end if;
      end if;
      if To_Fortran(Null_String) /= Null_Fortran_Character then
      if To_Fortran(Null_String) /= Null_Fortran_Character then
         Report.Failed("Incorrect result from procedure To_Fortran - 5");
         Report.Failed("Incorrect result from procedure To_Fortran - 5");
      end if;
      end if;
      -- Check that the Function To_Ada with a Fortran_Character parameter
      -- Check that the Function To_Ada with a Fortran_Character parameter
      -- will return the corresponding Ada String value.
      -- will return the corresponding Ada String value.
      String_1 := To_Ada(TC_Fortran_Character_1);
      String_1 := To_Ada(TC_Fortran_Character_1);
      if String_1 /= TC_String_1 then
      if String_1 /= TC_String_1 then
         Report.Failed("Incorrect value returned from function To_Ada - 1");
         Report.Failed("Incorrect value returned from function To_Ada - 1");
      end if;
      end if;
      Check_Length(To_Ada(TC_Fortran_Character_1),
      Check_Length(To_Ada(TC_Fortran_Character_1),
                   TC_Fortran_Character_1,
                   TC_Fortran_Character_1,
                   Num => 1);
                   Num => 1);
      Unb_String := Unb.To_Unbounded_String(To_Ada(TC_Fortran_Character_5));
      Unb_String := Unb.To_Unbounded_String(To_Ada(TC_Fortran_Character_5));
      if Unb_String /= TC_Unb_String then
      if Unb_String /= TC_Unb_String then
         Report.Failed("Incorrect value returned from function To_Ada - 2");
         Report.Failed("Incorrect value returned from function To_Ada - 2");
      end if;
      end if;
      Check_Length(To_Ada(TC_Fortran_Character_5),
      Check_Length(To_Ada(TC_Fortran_Character_5),
                   TC_Fortran_Character_5,
                   TC_Fortran_Character_5,
                   Num => 5);
                   Num => 5);
      Bnd_String := Bnd.To_Bounded_String
      Bnd_String := Bnd.To_Bounded_String
                         (To_Ada(TC_Fortran_Character_10));
                         (To_Ada(TC_Fortran_Character_10));
      if Bnd_String /= TC_Bnd_String then
      if Bnd_String /= TC_Bnd_String then
         Report.Failed("Incorrect value returned from function To_Ada - 3");
         Report.Failed("Incorrect value returned from function To_Ada - 3");
      end if;
      end if;
      Check_Length(To_Ada(TC_Fortran_Character_10),
      Check_Length(To_Ada(TC_Fortran_Character_10),
                   TC_Fortran_Character_10,
                   TC_Fortran_Character_10,
                   Num => 10);
                   Num => 10);
      String_20 := To_Ada(TC_Fortran_Character_20);
      String_20 := To_Ada(TC_Fortran_Character_20);
      if String_20 /= TC_String_20 then
      if String_20 /= TC_String_20 then
         Report.Failed("Incorrect value returned from function To_Ada - 4");
         Report.Failed("Incorrect value returned from function To_Ada - 4");
      end if;
      end if;
      Check_Length(To_Ada(TC_Fortran_Character_20),
      Check_Length(To_Ada(TC_Fortran_Character_20),
                   TC_Fortran_Character_20,
                   TC_Fortran_Character_20,
                   Num => 20);
                   Num => 20);
      if To_Ada(Null_Character_Set) /= Null_Character then
      if To_Ada(Null_Character_Set) /= Null_Character then
         Report.Failed("Incorrect value returned from function To_Ada - 5");
         Report.Failed("Incorrect value returned from function To_Ada - 5");
      end if;
      end if;
      -- Check the two functions when used in combination.
      -- Check the two functions when used in combination.
      if To_Ada(Item => To_Fortran("This is a test")) /=
      if To_Ada(Item => To_Fortran("This is a test")) /=
         "This is a test"                                or
         "This is a test"                                or
         To_Ada(To_Fortran("1234567890abcdeFGHIJ"))   /=
         To_Ada(To_Fortran("1234567890abcdeFGHIJ"))   /=
         Report.Ident_Str("1234567890abcdeFGHIJ")
         Report.Ident_Str("1234567890abcdeFGHIJ")
      then
      then
         Report.Failed("Incorrect result returned when using the " &
         Report.Failed("Incorrect result returned when using the " &
                       "functions To_Ada and To_Fortran in combination");
                       "functions To_Ada and To_Fortran in combination");
      end if;
      end if;
   exception
   exception
      when The_Error : others =>
      when The_Error : others =>
         Report.Failed("The following exception was raised in the " &
         Report.Failed("The following exception was raised in the " &
                       "Test_Block: " & Exception_Name(The_Error));
                       "Test_Block: " & Exception_Name(The_Error));
   end Test_Block;
   end Test_Block;
   Report.Result;
   Report.Result;
end CXB5002;
end CXB5002;
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.