├── ada.ads ├── text_io.ads ├── calendar.ads ├── direct_io.ads ├── io_exceptions.ads ├── machine_code.ads ├── sequential_io.ads ├── ada-directories-information.ads ├── ada-strings-less_case_insensitive.ads ├── ada-strings-equal_case_insensitive.ads ├── ada-characters.ads ├── ada-strings-unbounded-less_case_insensitive.ads ├── ada-float_text_io.ads ├── ada-unchecked_deallocate_subpool.ads ├── ada-integer_text_io.ads ├── unchecked_conversion.ads ├── ada-wide_characters.ads ├── ada-strings-hash_case_insensitive.ads ├── ada-float_wide_text_io.ads ├── unchecked_deallocation.ads ├── ada-integer_wide_text_io.ads ├── ada-strings-hash.ads ├── ada-strings-bounded-less_case_insensitive.ads ├── ada-wide_wide_characters.ads ├── ada-float_wide_wide_text_io.ads ├── ada-strings-unbounded-equal_case_insensitive.ads ├── ada-integer_wide_wide_text_io.ads ├── ada-numerics-real_arrays.ads ├── ada-strings-fixed-equal_case_insensitive.ads ├── ada-strings-fixed-less_case_insensitive.ads ├── ada-numerics-complex_types.ads ├── ada-dispatching-non_preemptive.ads ├── ada-strings-fixed-hash_case_insensitive.ads ├── ada-strings-wide_hash.ads ├── ada-strings-unbounded-hash_case_insensitive.ads ├── ada-complex_text_io.ads ├── ada-dispatching.ads ├── ada-strings-wide_wide_hash.ads ├── ada-synchronous_task_control-edf.ads ├── system-machine_code.ads ├── ada-strings-unbounded-hash.ads ├── ada-numerics-elementary_functions.ads ├── ada-strings-fixed-hash.ads ├── ada-strings-wide_unbounded-wide_hash.ads ├── ada-execution_time-interrupts.ads ├── ada-strings-wide_fixed-wide_hash.ads ├── ada-containers-generic_sort.ads ├── ada-strings-bounded-equal_case_insensitive.ads ├── ada-strings-wide_wide_unbounded-wide_wide_hash.ads ├── ada-containers.ads ├── ada-assertions.ads ├── ada-text_io-text_streams.ads ├── ada-strings-bounded-hash_case_insensitive.ads ├── system-multiprocessors.ads ├── ada-numerics-complex_elementary_functions.ads ├── ada-strings-wide_wide_fixed-wide_wide_hash.ads ├── ada-wide_text_io-text_streams.ads ├── ada-strings-bounded-hash.ads ├── ada-wide_wide_text_io-text_streams.ads ├── ada-interrupts-names.ads ├── ada-unchecked_conversion.ads ├── ada-unchecked_deallocation.ads ├── ada-calendar-time_zones.ads ├── README.md ├── ada-numerics-complex_arrays.ads ├── ada-strings-wide_bounded-wide_hash.ads ├── ada-numerics.ads ├── ada-strings-wide_wide_bounded-wide_wide_hash.ads ├── ada-io_exceptions.ads ├── ada-asynchronous_task_control.ads ├── ada-synchronous_barriers.ads ├── ada-containers-generic_array_sort.ads ├── ada-containers-generic_constrained_array_sort.ads ├── system-address_to_access_conversions.ads ├── ada-tags-generic_dispatching_constructor.ads ├── ada-synchronous_task_control.ads ├── ada-locales.ads ├── ada-dynamic_priorities.ads ├── ada-strings.ads ├── ada-command_line.ads ├── ada-task_attributes.ads ├── ada-iterator_interfaces.ads ├── ada-environment_variables.ads ├── ada-task_identification.ads ├── ada-containers-synchronized_queue_interfaces.ads ├── ada-dispatching-round_robin.ads ├── ada-storage_io.ads ├── ada-dispatching-edf.ads ├── ada-strings-utf_encoding-strings.ads ├── ada-finalization.ads ├── ada-decimal.ads ├── ada-strings-utf_encoding-wide_strings.ads ├── ada-text_io-bounded_io.ads ├── ada-text_io-unbounded_io.ads ├── ada-task_termination.ads ├── ada-strings-utf_encoding-wide_wide_strings.ads ├── ada-wide_text_io-bounded_io.ads ├── ada-real_time-timing_events.ads ├── ada-streams.ads ├── ada-interrupts.ads ├── ada-numerics-discrete_random.ads ├── ada-wide_text_io-unbounded_io.ads ├── ada-tags.ads ├── ada-numerics-float_random.ads ├── ada-strings-utf_encoding.ads ├── ada-wide_wide_text_io-wide_wide_bounded_io.ads ├── LICENSES └── BSD-3-Clause.txt ├── ada-directories-hierarchical_file_names.ads ├── ada-strings-utf_encoding-conversions.ads ├── ada-calendar-arithmetic.ads ├── ada-containers-unbounded_synchronized_queues.ads ├── ada-wide_wide_text_io-wide_wide_unbounded_io.ads ├── ada-execution_time-timers.ads ├── system-storage_pools.ads ├── ada-containers-bounded_synchronized_queues.ads ├── ada-text_io-complex_io.ads ├── ada-wide_text_io-complex_io.ads ├── ada-wide_wide_text_io-complex_io.ads ├── system-rpc.ads ├── ada-wide_characters-handling.ads ├── ada-containers-unbounded_priority_queues.ads ├── ada-wide_wide_characters-handling.ads ├── ada-calendar.ads ├── system-storage_elements.ads ├── ada-containers-bounded_priority_queues.ads ├── ada-strings-maps-constants.ads ├── system-multiprocessors-dispatching_domains.ads ├── interfaces-c-strings.ads ├── ada-containers-indefinite_holders.ads ├── interfaces-c-pointers.ads ├── ada-execution_time-group_budgets.ads ├── ada-sequential_io.ads ├── ada-strings-wide_maps-wide_constants.ads ├── ada-execution_time.ads ├── ada-characters-conversions.ads ├── ada-strings-wide_wide_maps-wide_wide_constants.ads ├── system-storage_pools-subpools.ads ├── ada-direct_io.ads ├── ada-numerics-generic_complex_elementary_functions.ads ├── ada-exceptions.ads ├── interfaces.ads ├── system.ads ├── ada-numerics-generic_elementary_functions.ads ├── ada-strings-maps.ads ├── ada-streams-stream_io.ads ├── ada-text_io-editing.ads ├── ada-characters-handling.ads ├── ada-wide_wide_text_io-editing.ads ├── ada-wide_text_io-editing.ads └── ada-strings-wide_maps.ads /ada.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada is 11 | pragma Pure (Ada); 12 | end Ada; 13 | -------------------------------------------------------------------------------- /text_io.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | 11 | with Ada.Text_IO; 12 | package Text_IO renames Ada.Text_IO; 13 | -------------------------------------------------------------------------------- /calendar.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | 11 | with Ada.Calendar; 12 | package Calendar renames Ada.Calendar; 13 | -------------------------------------------------------------------------------- /direct_io.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | 11 | with Ada.Direct_IO; 12 | generic package Direct_IO renames Ada.Direct_IO; 13 | -------------------------------------------------------------------------------- /io_exceptions.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | 11 | with Ada.IO_Exceptions; 12 | package IO_Exceptions renames Ada.IO_Exceptions; 13 | -------------------------------------------------------------------------------- /machine_code.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | 11 | with System.Machine_Code; 12 | package Machine_Code renames System.Machine_Code; 13 | -------------------------------------------------------------------------------- /sequential_io.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | 11 | with Ada.Sequential_IO; 12 | generic package Sequential_IO renames Ada.Sequential_IO; 13 | -------------------------------------------------------------------------------- /ada-directories-information.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.Directories.Information is 11 | 12 | end Ada.Directories.Information; 13 | -------------------------------------------------------------------------------- /ada-strings-less_case_insensitive.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | function Ada.Strings.Less_Case_Insensitive (Left, Right : String) 10 | return Boolean; 11 | pragma Pure(Ada.Strings.Less_Case_Insensitive); 12 | -------------------------------------------------------------------------------- /ada-strings-equal_case_insensitive.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | function Ada.Strings.Equal_Case_Insensitive (Left, Right : String) 10 | return Boolean; 11 | pragma Pure(Ada.Strings.Equal_Case_Insensitive); 12 | -------------------------------------------------------------------------------- /ada-characters.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.Characters is 11 | pragma Pure (Characters); 12 | end Ada.Characters; 13 | 14 | 15 | 16 | -------------------------------------------------------------------------------- /ada-strings-unbounded-less_case_insensitive.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | function Ada.Strings.Less_Case_Insensitive (Left, Right : String) 10 | return Boolean; 11 | pragma Pure(Ada.Strings.Less_Case_Insensitive); 12 | -------------------------------------------------------------------------------- /ada-float_text_io.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Text_IO; 11 | package Ada.Float_Text_IO is new Ada.Text_IO.Float_IO (Float); 12 | 13 | 14 | 15 | -------------------------------------------------------------------------------- /ada-unchecked_deallocate_subpool.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | with System.Storage_Pools.Subpools; 10 | procedure Ada.Unchecked_Deallocate_Subpool 11 | (Subpool : in out System.Storage_Pools.Subpools.Subpool_Handle); 12 | -------------------------------------------------------------------------------- /ada-integer_text_io.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Text_IO; 11 | package Ada.Integer_Text_IO is new Ada.Text_IO.Integer_IO (Integer); 12 | 13 | 14 | 15 | -------------------------------------------------------------------------------- /unchecked_conversion.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Unchecked_Conversion; 11 | generic function Unchecked_Conversion renames Ada.Unchecked_Conversion; 12 | -------------------------------------------------------------------------------- /ada-wide_characters.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.Wide_Characters is 11 | 12 | pragma Pure (Wide_Characters); 13 | 14 | end Ada.Wide_Characters; 15 | -------------------------------------------------------------------------------- /ada-strings-hash_case_insensitive.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | with Ada.Containers; 10 | function Ada.Strings.Hash_Case_Insensitive (Key : String) 11 | return Containers.Hash_Type; 12 | pragma Pure(Ada.Strings.Hash_Case_Insensitive); 13 | -------------------------------------------------------------------------------- /ada-float_wide_text_io.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Wide_Text_IO; 11 | package Ada.Float_Wide_Text_IO is new Ada.Wide_Text_IO.Float_IO (Float); 12 | 13 | 14 | 15 | -------------------------------------------------------------------------------- /unchecked_deallocation.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | 11 | with Ada.Unchecked_Deallocation; 12 | generic procedure Unchecked_Deallocation renames Ada.Unchecked_Deallocation; 13 | -------------------------------------------------------------------------------- /ada-integer_wide_text_io.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Wide_Text_IO; 11 | package Ada.Integer_Wide_Text_IO is new Ada.Wide_Text_IO.Integer_IO (Integer); 12 | 13 | 14 | 15 | -------------------------------------------------------------------------------- /ada-strings-hash.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Containers; 11 | 12 | function Ada.Strings.Hash (Key : in String) return Ada.Containers.Hash_Type; 13 | pragma Pure (Hash); 14 | -------------------------------------------------------------------------------- /ada-strings-bounded-less_case_insensitive.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | function Ada.Strings.Unbounded.Less_Case_Insensitive 10 | (Left, Right : Unbounded_String) return Boolean; 11 | pragma Preelaborate(Ada.Strings.Unbounded.Less_Case_Insensitive); 12 | -------------------------------------------------------------------------------- /ada-wide_wide_characters.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.Wide_Wide_Characters is 11 | 12 | pragma Pure (Wide_Wide_Characters); 13 | 14 | end Ada.Wide_Wide_Characters; 15 | -------------------------------------------------------------------------------- /ada-float_wide_wide_text_io.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Wide_Wide_Text_IO; 11 | 12 | package Ada.Float_Wide_Wide_Text_IO is 13 | new Ada.Wide_Wide_Text_IO.Float_IO (Float); 14 | -------------------------------------------------------------------------------- /ada-strings-unbounded-equal_case_insensitive.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | function Ada.Strings.Unbounded.Equal_Case_Insensitive 10 | (Left, Right : Unbounded_String) return Boolean; 11 | pragma Preelaborate(Ada.Strings.Unbounded.Equal_Case_Insensitive); 12 | -------------------------------------------------------------------------------- /ada-integer_wide_wide_text_io.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Wide_Wide_Text_IO; 11 | 12 | package Ada.Integer_Wide_Wide_Text_IO is 13 | new Ada.Wide_Wide_Text_IO.Integer_IO (Integer); 14 | -------------------------------------------------------------------------------- /ada-numerics-real_arrays.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Numerics.Generic_Real_Arrays; 11 | 12 | package Ada.Numerics.Real_Arrays is 13 | new Ada.Numerics.Generic_Real_Arrays (Float); 14 | 15 | -------------------------------------------------------------------------------- /ada-strings-fixed-equal_case_insensitive.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | with Ada.Strings.Equal_Case_Insensitive; 10 | function Ada.Strings.Fixed.Equal_Case_Insensitive 11 | (Left, Right : String) return Boolean 12 | renames Ada.Strings.Equal_Case_Insensitive; 13 | -------------------------------------------------------------------------------- /ada-strings-fixed-less_case_insensitive.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | with Ada.Strings.Less_Case_Insensitive; 10 | function Ada.Strings.Fixed.Less_Case_Insensitive 11 | (Left, Right : String) return Boolean 12 | renames Ada.Strings.Less_Case_Insensitive; 13 | -------------------------------------------------------------------------------- /ada-numerics-complex_types.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Numerics.Generic_Complex_Types; 11 | 12 | package Ada.Numerics.Complex_Types is 13 | new Ada.Numerics.Generic_Complex_Types (Float); 14 | -------------------------------------------------------------------------------- /ada-dispatching-non_preemptive.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | package Ada.Dispatching.Non_Preemptive is 10 | pragma Preelaborate(Non_Preemptive); 11 | procedure Yield_To_Higher; 12 | procedure Yield_To_Same_Or_Higher renames Yield; 13 | end Ada.Dispatching.Non_Preemptive; 14 | -------------------------------------------------------------------------------- /ada-strings-fixed-hash_case_insensitive.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | with Ada.Containers, Ada.Strings.Hash_Case_Insensitive; 10 | function Ada.Strings.Fixed.Hash_Case_Insensitive (Key : String) 11 | return Containers.Hash_Type renames Ada.Strings.Hash_Case_Insensitive; 12 | -------------------------------------------------------------------------------- /ada-strings-wide_hash.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Containers; 11 | 12 | function Ada.Strings.Wide_Hash (Key : in Wide_String) 13 | return Ada.Containers.Hash_Type; 14 | pragma Pure (Wide_Hash); 15 | -------------------------------------------------------------------------------- /ada-strings-unbounded-hash_case_insensitive.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | with Ada.Containers; 10 | function Ada.Strings.Unbounded.Hash_Case_Insensitive 11 | (Key : Unbounded_String) return Containers.Hash_Type; 12 | pragma Preelaborate(Ada.Strings.Unbounded.Hash_Case_Insensitive); 13 | -------------------------------------------------------------------------------- /ada-complex_text_io.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Numerics.Complex_Types; 11 | with Ada.Text_IO.Complex_IO; 12 | 13 | package Ada.Complex_Text_IO is 14 | new Ada.Text_IO.Complex_IO (Ada.Numerics.Complex_Types); 15 | -------------------------------------------------------------------------------- /ada-dispatching.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.Dispatching is 11 | 12 | pragma Pure (Dispatching); 13 | 14 | procedure Yield; 15 | 16 | Dispatching_Policy_Error : exception; 17 | 18 | end Ada.Dispatching; 19 | -------------------------------------------------------------------------------- /ada-strings-wide_wide_hash.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Containers; 11 | 12 | function Ada.Strings.Wide_Wide_Hash (Key : in Wide_Wide_String) 13 | return Ada.Containers.Hash_Type; 14 | pragma Pure (Wide_Wide_Hash); 15 | -------------------------------------------------------------------------------- /ada-synchronous_task_control-edf.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | package Ada.Synchronous_Task_Control.EDF is 10 | procedure Suspend_Until_True_And_Set_Deadline 11 | (S : in out Suspension_Object; 12 | TS : in Ada.Real_Time.Time_Span); 13 | end Ada.Synchronous_Task_Control.EDF; 14 | -------------------------------------------------------------------------------- /system-machine_code.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package System.Machine_Code is 11 | -- The contents of the library package System.Machine_Code (if provided) 12 | -- are implementation defined. 13 | end System.Machine_Code; 14 | -------------------------------------------------------------------------------- /ada-strings-unbounded-hash.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Containers; 11 | 12 | function Ada.Strings.Unbounded.Hash (Key : in Unbounded_String) 13 | return Ada.Containers.Hash_Type; 14 | 15 | pragma Preelaborate (Hash); 16 | -------------------------------------------------------------------------------- /ada-numerics-elementary_functions.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Numerics.Generic_Elementary_Functions; 11 | 12 | package Ada.Numerics.Elementary_Functions is 13 | new Ada.Numerics.Generic_Elementary_Functions (Float); 14 | 15 | 16 | -------------------------------------------------------------------------------- /ada-strings-fixed-hash.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Containers, Ada.Strings.Hash; 11 | 12 | function Ada.Strings.Fixed.Hash (Key : in String) 13 | return Ada.Containers.Hash_Type 14 | renames Ada.Strings.Hash; 15 | pragma Pure (Hash); 16 | -------------------------------------------------------------------------------- /ada-strings-wide_unbounded-wide_hash.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Containers; 11 | 12 | function Ada.Strings.Wide_Unbounded.Wide_Hash (Key : in Unbounded_Wide_String) 13 | return Ada.Containers.Hash_Type; 14 | 15 | pragma Preelaborate (Wide_Hash); 16 | -------------------------------------------------------------------------------- /ada-execution_time-interrupts.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | with Ada.Interrupts; 10 | package Ada.Execution_Time.Interrupts is 11 | function Clock (Interrupt : Ada.Interrupts.Interrupt_Id) 12 | return CPU_Time; 13 | function Supported (Interrupt : Ada.Interrupts.Interrupt_Id) 14 | return Boolean; 15 | end Ada.Execution_Time.Interrupts; 16 | -------------------------------------------------------------------------------- /ada-strings-wide_fixed-wide_hash.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Containers, Ada.Strings.Wide_Hash; 11 | 12 | function Ada.Strings.Wide_Fixed.Wide_Hash (Key : in Wide_String) 13 | return Ada.Containers.Hash_Type 14 | renames Ada.Strings.Wide_Hash; 15 | pragma Pure (Wide_Hash); 16 | -------------------------------------------------------------------------------- /ada-containers-generic_sort.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | generic 10 | type Index_Type is (<>); 11 | with function Before (Left, Right : Index_Type) return Boolean; 12 | with procedure Swap (Left, Right : in Index_Type); 13 | procedure Ada.Containers.Generic_Sort 14 | (First, Last : Index_Type'Base); 15 | pragma Pure(Ada.Containers.Generic_Sort); 16 | -------------------------------------------------------------------------------- /ada-strings-bounded-equal_case_insensitive.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | generic 10 | with package Bounded is 11 | new Ada.Strings.Bounded.Generic_Bounded_Length (<>); 12 | function Ada.Strings.Bounded.Equal_Case_Insensitive 13 | (Left, Right : Bounded.Bounded_String) return Boolean; 14 | pragma Preelaborate(Ada.Strings.Bounded.Equal_Case_Insensitive); 15 | -------------------------------------------------------------------------------- /ada-strings-wide_wide_unbounded-wide_wide_hash.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Containers; 11 | 12 | function Ada.Strings.Wide_Wide_Unbounded.Wide_Wide_Hash 13 | (Key : in Unbounded_Wide_Wide_String) 14 | return Ada.Containers.Hash_Type; 15 | 16 | pragma Preelaborate (Wide_Wide_Hash); 17 | -------------------------------------------------------------------------------- /ada-containers.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.Containers is 11 | pragma Pure (Containers); 12 | 13 | type Hash_Type is mod implementation_defined; 14 | 15 | type Count_Type is range 0 .. implementation_defined; 16 | 17 | Capacity_Error : exception; 18 | 19 | end Ada.Containers; 20 | -------------------------------------------------------------------------------- /ada-assertions.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.Assertions is 11 | 12 | pragma Pure (Assertions); 13 | 14 | Assertion_Error : exception; 15 | 16 | procedure Assert (Check : in Boolean); 17 | 18 | procedure Assert (Check : in Boolean; Message : in String); 19 | 20 | end Ada.Assertions; 21 | -------------------------------------------------------------------------------- /ada-text_io-text_streams.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Streams; 11 | 12 | package Ada.Text_IO.Text_Streams is 13 | type Stream_Access is access all Streams.Root_Stream_Type'Class; 14 | 15 | function Stream (File : in File_Type) return Stream_Access; 16 | end Ada.Text_IO.Text_Streams; 17 | 18 | 19 | 20 | -------------------------------------------------------------------------------- /ada-strings-bounded-hash_case_insensitive.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | with Ada.Containers; 10 | generic 11 | with package Bounded is 12 | new Ada.Strings.Bounded.Generic_Bounded_Length (<>); 13 | function Ada.Strings.Bounded.Hash_Case_Insensitive 14 | (Key : Bounded.Bounded_String) return Containers.Hash_Type; 15 | pragma Preelaborate(Ada.Strings.Bounded.Hash_Case_Insensitive); 16 | -------------------------------------------------------------------------------- /system-multiprocessors.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | package System.Multiprocessors is 10 | pragma Preelaborate(Multiprocessors); 11 | 12 | type CPU_Range is range 0 .. implementation_defined; 13 | Not_A_Specific_CPU : constant CPU_Range := 0; 14 | subtype CPU is CPU_Range range 1 .. CPU_Range'Last; 15 | 16 | function Number_Of_CPUs return CPU; 17 | end System.Multiprocessors; 18 | -------------------------------------------------------------------------------- /ada-numerics-complex_elementary_functions.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Numerics.Complex_Types; 11 | with Ada.Numerics.Generic_Complex_Elementary_Functions; 12 | 13 | package Ada.Numerics.Complex_Elementary_Functions is 14 | new Ada.Numerics.Generic_Complex_Elementary_Functions 15 | (Ada.Numerics.Complex_Types); 16 | -------------------------------------------------------------------------------- /ada-strings-wide_wide_fixed-wide_wide_hash.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Containers, Ada.Strings.Wide_Wide_Hash; 11 | 12 | function Ada.Strings.Wide_Wide_Fixed.Wide_Wide_Hash (Key : in Wide_Wide_String) 13 | return Ada.Containers.Hash_Type 14 | renames Ada.Strings.Wide_Wide_Hash; 15 | pragma Pure (Wide_Wide_Hash); 16 | -------------------------------------------------------------------------------- /ada-wide_text_io-text_streams.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Streams; 11 | 12 | package Ada.Wide_Text_IO.Text_Streams is 13 | type Stream_Access is access all Streams.Root_Stream_Type'Class; 14 | 15 | function Stream (File : in File_Type) return Stream_Access; 16 | end Ada.Wide_Text_IO.Text_Streams; 17 | 18 | 19 | 20 | -------------------------------------------------------------------------------- /ada-strings-bounded-hash.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Containers; 11 | 12 | generic 13 | with package Bounded is 14 | new Ada.Strings.Bounded.Generic_Bounded_Length (<>); 15 | 16 | function Ada.Strings.Bounded.Hash (Key : in Bounded.Bounded_String) 17 | return Containers.Hash_Type; 18 | pragma Preelaborate (Hash); 19 | -------------------------------------------------------------------------------- /ada-wide_wide_text_io-text_streams.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Streams; 11 | package Ada.Wide_Wide_Text_IO.Text_Streams is 12 | type Stream_Access is access all Streams.Root_Stream_Type'Class; 13 | 14 | function Stream (File : in File_Type) return Stream_Access; 15 | end Ada.Wide_Wide_Text_IO.Text_Streams; 16 | 17 | 18 | -------------------------------------------------------------------------------- /ada-interrupts-names.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.Interrupts.Names is 11 | 12 | -- implementation_defined : constant Interrupt_ID := 13 | -- implementation_defined; 14 | -- . . . 15 | -- implementation_defined : constant Interrupt_ID := 16 | -- implementation_defined; 17 | 18 | end Ada.Interrupts.Names; 19 | -------------------------------------------------------------------------------- /ada-unchecked_conversion.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | generic 11 | type Source (<>) is limited private; 12 | type Target (<>) is limited private; 13 | function Ada.Unchecked_Conversion (S : Source) return Target; 14 | 15 | pragma Convention (Intrinsic, Ada.Unchecked_Conversion); 16 | pragma Pure (Ada.Unchecked_Conversion); 17 | 18 | 19 | 20 | -------------------------------------------------------------------------------- /ada-unchecked_deallocation.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | generic 11 | type Object (<>) is limited private; 12 | type Name is access Object; 13 | procedure Ada.Unchecked_Deallocation (X : in out Name); 14 | 15 | pragma Convention (Intrinsic, Ada.Unchecked_Deallocation); 16 | pragma Preelaborate (Ada.Unchecked_Deallocation); 17 | 18 | 19 | 20 | -------------------------------------------------------------------------------- /ada-calendar-time_zones.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.Calendar.Time_Zones is 11 | 12 | -- Time zone manipulation: 13 | 14 | type Time_Offset is range -28 * 60 .. 28 * 60; 15 | 16 | Unknown_Zone_Error : exception; 17 | 18 | function UTC_Time_Offset (Date : in Time := Clock) return Time_Offset; 19 | 20 | end Ada.Calendar.Time_Zones; 21 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | Standard Ada library specification _(adalib)_ 2 | ============================================= 3 | 4 | [![reuse compliant](https://img.shields.io/badge/reuse-compliant-green.svg)](https://reuse.software/) 5 | 6 | > Standard Ada library specification as defined in Reference Manual 7 | 8 | This repository contains texts of predefined Ada library units as 9 | defined in the Ada Reference Manual. Implementation defined values 10 | are represented as *implementation_defined* identifier. 11 | Private types are completed as *null record*. 12 | 13 | ## Maintainer 14 | 15 | [@MaximReznik](https://github.com/reznikmm). 16 | 17 | ## Contribute 18 | 19 | Feel free to dive in! 20 | [Open an issue](https://github.com/reznikmm/adalib/issues/new) or submit PRs. 21 | 22 | ## License 23 | 24 | [BSD](LICENSES/BSD-3-Clause.txt) © Maxim Reznik 25 | -------------------------------------------------------------------------------- /ada-numerics-complex_arrays.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Numerics.Complex_Types; 11 | with Ada.Numerics.Generic_Complex_Arrays; 12 | with Ada.Numerics.Real_Arrays; 13 | 14 | package Ada.Numerics.Complex_Arrays is 15 | new Ada.Numerics.Generic_Complex_Arrays (Ada.Numerics.Real_Arrays, 16 | Ada.Numerics.Complex_Types); 17 | -------------------------------------------------------------------------------- /ada-strings-wide_bounded-wide_hash.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Containers; 11 | 12 | generic 13 | with package Bounded is 14 | new Ada.Strings.Wide_Bounded.Generic_Bounded_Length (<>); 15 | 16 | function Ada.Strings.Wide_Bounded.Wide_Hash 17 | (Key : in Bounded.Bounded_Wide_String) 18 | return Containers.Hash_Type; 19 | 20 | pragma Preelaborate (Wide_Hash); 21 | -------------------------------------------------------------------------------- /ada-numerics.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.Numerics is 11 | pragma Pure (Numerics); 12 | 13 | Argument_Error : exception; 14 | 15 | Pi : constant := 16 | 3.14159_26535_89793_23846_26433_83279_50288_41971_69399_37511; 17 | π : constant := Pi; 18 | e : constant := 19 | 2.71828_18284_59045_23536_02874_71352_66249_77572_47093_69996; 20 | end Ada.Numerics; 21 | 22 | 23 | 24 | -------------------------------------------------------------------------------- /ada-strings-wide_wide_bounded-wide_wide_hash.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Containers; 11 | 12 | generic 13 | with package Bounded is 14 | new Ada.Strings.Wide_Wide_Bounded.Generic_Bounded_Length (<>); 15 | 16 | function Ada.Strings.Wide_Wide_Bounded.Wide_Wide_Hash 17 | (Key : in Wide_Wide_Bounded.Bounded_Wide_Wide_String) 18 | return Containers.Hash_Type; 19 | pragma Preelaborate (Wide_Wide_Hash); 20 | -------------------------------------------------------------------------------- /ada-io_exceptions.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.IO_Exceptions is 11 | pragma Pure (IO_Exceptions); 12 | 13 | Status_Error : exception; 14 | Mode_Error : exception; 15 | Name_Error : exception; 16 | Use_Error : exception; 17 | Device_Error : exception; 18 | End_Error : exception; 19 | Data_Error : exception; 20 | Layout_Error : exception; 21 | 22 | end Ada.IO_Exceptions; 23 | 24 | 25 | 26 | -------------------------------------------------------------------------------- /ada-asynchronous_task_control.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Task_Identification; 11 | 12 | package Ada.Asynchronous_Task_Control is 13 | 14 | pragma Preelaborate (Asynchronous_Task_Control); 15 | 16 | procedure Hold (T : in Ada.Task_Identification.Task_Id); 17 | 18 | procedure Continue (T : in Ada.Task_Identification.Task_Id); 19 | 20 | function Is_Held (T : in Ada.Task_Identification.Task_Id) return Boolean; 21 | 22 | end Ada.Asynchronous_Task_Control; 23 | -------------------------------------------------------------------------------- /ada-synchronous_barriers.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | package Ada.Synchronous_Barriers is 10 | pragma Preelaborate(Synchronous_Barriers); 11 | 12 | subtype Barrier_Limit is Positive range 1 .. implementation_defined; 13 | 14 | type Synchronous_Barrier (Release_Threshold : Barrier_Limit) is limited private; 15 | 16 | procedure Wait_For_Release (The_Barrier : in out Synchronous_Barrier; 17 | Notified : out Boolean); 18 | 19 | private 20 | -- not specified by the language 21 | end Ada.Synchronous_Barriers; 22 | -------------------------------------------------------------------------------- /ada-containers-generic_array_sort.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | generic 11 | type Index_Type is (<>); 12 | type Element_Type is private; 13 | type Array_Type is array (Index_Type range <>) of Element_Type; 14 | 15 | with function "<" (Left : in Element_Type; 16 | Right : in Element_Type) 17 | return Boolean is <>; 18 | 19 | procedure Ada.Containers.Generic_Array_Sort (Container : in out Array_Type); 20 | pragma Pure (Ada.Containers.Generic_Array_Sort); 21 | -------------------------------------------------------------------------------- /ada-containers-generic_constrained_array_sort.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | generic 11 | type Index_Type is (<>); 12 | type Element_Type is private; 13 | type Array_Type is array (Index_Type) of Element_Type; 14 | 15 | with function "<" (Left : in Element_Type; 16 | Right : in Element_Type) 17 | return Boolean is <>; 18 | 19 | procedure Ada.Containers.Generic_Constrained_Array_Sort 20 | (Container : in out Array_Type); 21 | pragma Pure (Ada.Containers.Generic_Constrained_Array_Sort); 22 | -------------------------------------------------------------------------------- /system-address_to_access_conversions.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | generic 11 | type Object (<>) is limited private; 12 | package System.Address_To_Access_Conversions is 13 | pragma Preelaborate (Address_To_Access_Conversions); 14 | 15 | type Object_Pointer is access all Object; 16 | function To_Pointer (Value : Address) return Object_Pointer; 17 | function To_Address (Value : Object_Pointer) return Address; 18 | 19 | pragma Convention (Intrinsic, To_Pointer); 20 | pragma Convention (Intrinsic, To_Address); 21 | end System.Address_To_Access_Conversions; 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /ada-tags-generic_dispatching_constructor.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | generic 11 | type T (<>) is abstract tagged limited private; 12 | type Parameters (<>) is limited private; 13 | 14 | with function Constructor (Params : not null access Parameters) 15 | return T is abstract; 16 | 17 | function Ada.Tags.Generic_Dispatching_Constructor 18 | (The_Tag : in Tag; 19 | Params : not null access Parameters) 20 | return T'Class; 21 | pragma Preelaborate (Ada.Tags.Generic_Dispatching_Constructor); 22 | pragma Convention (Intrinsic, Ada.Tags.Generic_Dispatching_Constructor); 23 | -------------------------------------------------------------------------------- /ada-synchronous_task_control.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.Synchronous_Task_Control is 11 | 12 | pragma Preelaborate (Synchronous_Task_Control); 13 | 14 | type Suspension_Object is limited private; 15 | 16 | procedure Set_True (S : in out Suspension_Object); 17 | 18 | procedure Set_False (S : in out Suspension_Object); 19 | 20 | function Current_State (S : in Suspension_Object) return Boolean; 21 | 22 | procedure Suspend_Until_True (S : in out Suspension_Object); 23 | 24 | private 25 | 26 | pragma Import (Ada, Suspension_Object); 27 | 28 | end Ada.Synchronous_Task_Control; 29 | -------------------------------------------------------------------------------- /ada-locales.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | package Ada.Locales is 10 | pragma Preelaborate(Locales); 11 | pragma Remote_Types(Locales); 12 | 13 | type Language_Code is new String (1 .. 3) 14 | with Dynamic_Predicate => 15 | (for all E of Language_Code => E in 'a' .. 'z'); 16 | type Country_Code is new String (1 .. 2) 17 | with Dynamic_Predicate => 18 | (for all E of Country_Code => E in 'A' .. 'Z'); 19 | 20 | Language_Unknown : constant Language_Code := "und"; 21 | Country_Unknown : constant Country_Code := "ZZ"; 22 | 23 | function Language return Language_Code; 24 | function Country return Country_Code; 25 | 26 | end Ada.Locales; 27 | -------------------------------------------------------------------------------- /ada-dynamic_priorities.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Task_Identification; -- See C.7.1 11 | with System; 12 | 13 | package Ada.Dynamic_Priorities is 14 | 15 | pragma Preelaborate (Dynamic_Priorities); 16 | 17 | procedure Set_Priority (Priority : in System.Any_Priority; 18 | T : in Ada.Task_Identification.Task_Id 19 | := Ada.Task_Identification.Current_Task); 20 | 21 | function Get_Priority (T : in Ada.Task_Identification.Task_Id 22 | := Ada.Task_Identification.Current_Task) 23 | return System.Any_Priority; 24 | 25 | end Ada.Dynamic_Priorities; 26 | -------------------------------------------------------------------------------- /ada-strings.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.Strings is 11 | pragma Pure (Strings); 12 | 13 | Space : constant Character := ' '; 14 | Wide_Space : constant Wide_Character := ' '; 15 | Wide_Wide_Space : constant Wide_Wide_Character := ' '; 16 | 17 | Length_Error, Pattern_Error, Index_Error, Translation_Error 18 | : exception; 19 | 20 | type Alignment is (Left, Right, Center); 21 | type Truncation is (Left, Right, Error); 22 | type Membership is (Inside, Outside); 23 | type Direction is (Forward, Backward); 24 | type Trim_End is (Left, Right, Both); 25 | 26 | end Ada.Strings; 27 | 28 | 29 | 30 | -------------------------------------------------------------------------------- /ada-command_line.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.Command_Line is 11 | pragma Preelaborate (Command_Line); 12 | 13 | function Argument_Count return Natural; 14 | 15 | function Argument (Number : in Positive) return String; 16 | 17 | function Command_Name return String; 18 | 19 | type Exit_Status is range implementation_defined .. implementation_defined; 20 | 21 | Success : constant Exit_Status; 22 | Failure : constant Exit_Status; 23 | 24 | procedure Set_Exit_Status (Code : in Exit_Status); 25 | 26 | private 27 | 28 | pragma Import (Ada, Success); 29 | pragma Import (Ada, Failure); 30 | 31 | end Ada.Command_Line; 32 | 33 | 34 | 35 | -------------------------------------------------------------------------------- /ada-task_attributes.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Task_Identification; use Ada.Task_Identification; 11 | 12 | generic 13 | type Attribute is private; 14 | Initial_Value : in Attribute; 15 | package Ada.Task_Attributes is 16 | 17 | type Attribute_Handle is access all Attribute; 18 | 19 | function Value (T : Task_Id := Current_Task) return Attribute; 20 | 21 | function Reference (T : Task_Id := Current_Task) return Attribute_Handle; 22 | 23 | procedure Set_Value (Val : in Attribute; 24 | T : in Task_Id := Current_Task); 25 | 26 | procedure Reinitialize (T : in Task_Id := Current_Task); 27 | 28 | end Ada.Task_Attributes; 29 | 30 | -------------------------------------------------------------------------------- /ada-iterator_interfaces.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | generic 10 | type Cursor; 11 | with function Has_Element (Position : Cursor) return Boolean; 12 | package Ada.Iterator_Interfaces is 13 | pragma Pure (Iterator_Interfaces); 14 | 15 | type Forward_Iterator is limited interface; 16 | function First (Object : Forward_Iterator) return Cursor is abstract; 17 | function Next (Object : Forward_Iterator; Position : Cursor) 18 | return Cursor is abstract; 19 | 20 | type Reversible_Iterator is limited interface and Forward_Iterator; 21 | function Last (Object : Reversible_Iterator) return Cursor is abstract; 22 | function Previous (Object : Reversible_Iterator; Position : Cursor) 23 | return Cursor is abstract; 24 | 25 | end Ada.Iterator_Interfaces; 26 | -------------------------------------------------------------------------------- /ada-environment_variables.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.Environment_Variables is 11 | 12 | pragma Preelaborate (Environment_Variables); 13 | 14 | function Value (Name : in String) return String; 15 | 16 | function Value (Name : in String; Default : in String) return String; 17 | 18 | function Exists (Name : in String) return Boolean; 19 | 20 | procedure Set (Name : in String; 21 | Value : in String); 22 | 23 | procedure Clear (Name : in String); 24 | 25 | procedure Clear; 26 | 27 | procedure Iterate 28 | (Process : not null access procedure 29 | (Name : in String; 30 | Value : in String)); 31 | 32 | end Ada.Environment_Variables; 33 | -------------------------------------------------------------------------------- /ada-task_identification.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.Task_Identification is 11 | pragma Preelaborate(Task_Identification); 12 | 13 | type Task_Id is private; 14 | pragma Preelaborable_Initialization (Task_Id); 15 | 16 | Null_Task_Id : constant Task_Id; 17 | 18 | function "=" (Left, Right : Task_Id) return Boolean; 19 | 20 | function Image (T : Task_Id) return String; 21 | 22 | function Current_Task return Task_Id; 23 | procedure Abort_Task (T : in out Task_Id); 24 | 25 | function Is_Terminated (T : Task_Id) return Boolean; 26 | function Is_Callable (T : Task_Id) return Boolean; 27 | private 28 | pragma Import (Ada, Task_Id); 29 | pragma Import (Ada, Null_Task_Id); 30 | end Ada.Task_Identification; 31 | -------------------------------------------------------------------------------- /ada-containers-synchronized_queue_interfaces.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | generic 10 | type Element_Type is private; 11 | package Ada.Containers.Synchronized_Queue_Interfaces is 12 | pragma Pure(Synchronized_Queue_Interfaces); 13 | 14 | type Queue is synchronized interface; 15 | 16 | procedure Enqueue 17 | (Container : in out Queue; 18 | New_Item : in Element_Type) is abstract 19 | with Synchronization => By_Entry; 20 | 21 | procedure Dequeue 22 | (Container : in out Queue; 23 | Element : out Element_Type) is abstract 24 | with Synchronization => By_Entry; 25 | 26 | function Current_Use (Container : Queue) return Count_Type is abstract; 27 | function Peak_Use (Container : Queue) return Count_Type is abstract; 28 | 29 | end Ada.Containers.Synchronized_Queue_Interfaces; 30 | -------------------------------------------------------------------------------- /ada-dispatching-round_robin.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Real_Time; 11 | with System; 12 | 13 | package Ada.Dispatching.Round_Robin is 14 | 15 | Default_Quantum : constant Ada.Real_Time.Time_Span := 16 | implementation_defined; 17 | 18 | procedure Set_Quantum (Pri : in System.Priority; 19 | Quantum : in Ada.Real_Time.Time_Span); 20 | 21 | procedure Set_Quantum (Low : in System.Priority; 22 | High : in System.Priority; 23 | Quantum : in Ada.Real_Time.Time_Span); 24 | 25 | function Actual_Quantum (Pri : in System.Priority) 26 | return Ada.Real_Time.Time_Span; 27 | 28 | function Is_Round_Robin (Pri : in System.Priority) return Boolean; 29 | 30 | end Ada.Dispatching.Round_Robin; 31 | -------------------------------------------------------------------------------- /ada-storage_io.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.IO_Exceptions; 11 | with System.Storage_Elements; 12 | 13 | generic 14 | type Element_Type is private; 15 | package Ada.Storage_IO is 16 | pragma Preelaborate (Storage_IO); 17 | 18 | Buffer_Size : constant System.Storage_Elements.Storage_Count 19 | := implementation_defined; 20 | 21 | subtype Buffer_Type is 22 | System.Storage_Elements.Storage_Array (1 .. Buffer_Size); 23 | 24 | -- Input and output operations 25 | 26 | procedure Read (Buffer : in Buffer_Type; Item : out Element_Type); 27 | procedure Write (Buffer : out Buffer_Type; Item : in Element_Type); 28 | 29 | -- Exceptions 30 | 31 | Data_Error : exception renames IO_Exceptions.Data_Error; 32 | 33 | end Ada.Storage_IO; 34 | 35 | 36 | 37 | 38 | -------------------------------------------------------------------------------- /ada-dispatching-edf.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Real_Time; 11 | with Ada.Task_Identification; 12 | 13 | package Ada.Dispatching.EDF is 14 | 15 | subtype Deadline is Ada.Real_Time.Time; 16 | 17 | Default_Deadline : constant Deadline := Ada.Real_Time.Time_Last; 18 | 19 | procedure Set_Deadline (D : in Deadline; 20 | T : in Ada.Task_Identification.Task_Id 21 | := Ada.Task_Identification.Current_Task); 22 | 23 | procedure Delay_Until_And_Set_Deadline 24 | (Delay_Until_Time : in Ada.Real_Time.Time; 25 | Deadline_Offset : in Ada.Real_Time.Time_Span); 26 | 27 | function Get_Deadline (T : Ada.Task_Identification.Task_Id 28 | := Ada.Task_Identification.Current_Task) 29 | return Deadline; 30 | 31 | end Ada.Dispatching.EDF; 32 | -------------------------------------------------------------------------------- /ada-strings-utf_encoding-strings.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | package Ada.Strings.UTF_Encoding.Strings is 10 | pragma Pure (Strings); 11 | 12 | -- Encoding / decoding between String and various encoding schemes 13 | function Encode (Item : String; 14 | Output_Scheme : Encoding_Scheme; 15 | Output_BOM : Boolean := False) return UTF_String; 16 | 17 | function Encode (Item : String; 18 | Output_BOM : Boolean := False) return UTF_8_String; 19 | 20 | function Encode (Item : String; 21 | Output_BOM : Boolean := False) 22 | return UTF_16_Wide_String; 23 | 24 | function Decode (Item : UTF_String; 25 | Input_Scheme : Encoding_Scheme) return String; 26 | 27 | function Decode (Item : UTF_8_String) return String; 28 | 29 | function Decode (Item : UTF_16_Wide_String) return String; 30 | 31 | end Ada.Strings.UTF_Encoding.Strings; 32 | -------------------------------------------------------------------------------- /ada-finalization.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.Finalization is 11 | pragma Preelaborate (Finalization); 12 | pragma Remote_Types (Finalization); 13 | 14 | type Controlled is abstract tagged private; 15 | pragma Preelaborable_Initialization (Controlled); 16 | 17 | procedure Initialize (Object : in out Controlled) is null; 18 | procedure Adjust (Object : in out Controlled) is null; 19 | procedure Finalize (Object : in out Controlled) is null; 20 | 21 | type Limited_Controlled is abstract tagged limited private; 22 | pragma Preelaborable_Initialization (Limited_Controlled); 23 | 24 | procedure Initialize (Object : in out Limited_Controlled) is null; 25 | procedure Finalize (Object : in out Limited_Controlled) is null; 26 | 27 | private 28 | 29 | pragma Import (Ada, Controlled); 30 | pragma Import (Ada, Limited_Controlled); 31 | 32 | end Ada.Finalization; 33 | 34 | 35 | 36 | -------------------------------------------------------------------------------- /ada-decimal.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.Decimal is 11 | 12 | pragma Pure (Decimal); 13 | 14 | Max_Scale : constant := implementation_defined; 15 | Min_Scale : constant := implementation_defined; 16 | 17 | Min_Delta : constant := 10.0**(-Max_Scale); 18 | Max_Delta : constant := 10.0**(-Min_Scale); 19 | 20 | Max_Decimal_Digits : constant := implementation_defined; 21 | 22 | generic 23 | type Dividend_Type is delta <> digits <>; 24 | type Divisor_Type is delta <> digits <>; 25 | type Quotient_Type is delta <> digits <>; 26 | type Remainder_Type is delta <> digits <>; 27 | 28 | procedure Divide (Dividend : in Dividend_Type; 29 | Divisor : in Divisor_Type; 30 | Quotient : out Quotient_Type; 31 | Remainder : out Remainder_Type); 32 | pragma Convention (Intrinsic, Divide); 33 | 34 | end Ada.Decimal; 35 | -------------------------------------------------------------------------------- /ada-strings-utf_encoding-wide_strings.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | package Ada.Strings.UTF_Encoding.Wide_Strings is 10 | pragma Pure (Wide_Strings); 11 | 12 | -- Encoding / decoding between Wide_String and various encoding schemes 13 | function Encode (Item : Wide_String; 14 | Output_Scheme : Encoding_Scheme; 15 | Output_BOM : Boolean := False) return UTF_String; 16 | 17 | function Encode (Item : Wide_String; 18 | Output_BOM : Boolean := False) return UTF_8_String; 19 | 20 | function Encode (Item : Wide_String; 21 | Output_BOM : Boolean := False) 22 | return UTF_16_Wide_String; 23 | 24 | function Decode (Item : UTF_String; 25 | Input_Scheme : Encoding_Scheme) return Wide_String; 26 | 27 | function Decode (Item : UTF_8_String) return Wide_String; 28 | 29 | function Decode (Item : UTF_16_Wide_String) return Wide_String; 30 | 31 | end Ada.Strings.UTF_Encoding.Wide_Strings; 32 | -------------------------------------------------------------------------------- /ada-text_io-bounded_io.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Strings.Bounded; 11 | 12 | generic 13 | with package Bounded is 14 | new Ada.Strings.Bounded.Generic_Bounded_Length (<>); 15 | package Ada.Text_IO.Bounded_IO is 16 | 17 | procedure Put 18 | (File : in File_Type; 19 | Item : in Bounded.Bounded_String); 20 | 21 | procedure Put 22 | (Item : in Bounded.Bounded_String); 23 | 24 | procedure Put_Line 25 | (File : in File_Type; 26 | Item : in Bounded.Bounded_String); 27 | 28 | procedure Put_Line 29 | (Item : in Bounded.Bounded_String); 30 | 31 | function Get_Line 32 | (File : in File_Type) 33 | return Bounded.Bounded_String; 34 | 35 | function Get_Line 36 | return Bounded.Bounded_String; 37 | 38 | procedure Get_Line 39 | (File : in File_Type; Item : out Bounded.Bounded_String); 40 | 41 | procedure Get_Line 42 | (Item : out Bounded.Bounded_String); 43 | 44 | end Ada.Text_IO.Bounded_IO; 45 | -------------------------------------------------------------------------------- /ada-text_io-unbounded_io.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Strings.Unbounded; 11 | 12 | package Ada.Text_IO.Unbounded_IO is 13 | 14 | procedure Put 15 | (File : in File_Type; 16 | Item : in Strings.Unbounded.Unbounded_String); 17 | 18 | procedure Put 19 | (Item : in Strings.Unbounded.Unbounded_String); 20 | 21 | procedure Put_Line 22 | (File : in File_Type; 23 | Item : in Strings.Unbounded.Unbounded_String); 24 | 25 | procedure Put_Line 26 | (Item : in Strings.Unbounded.Unbounded_String); 27 | 28 | function Get_Line 29 | (File : in File_Type) 30 | return Strings.Unbounded.Unbounded_String; 31 | 32 | function Get_Line 33 | return Strings.Unbounded.Unbounded_String; 34 | 35 | procedure Get_Line 36 | (File : in File_Type; Item : out Strings.Unbounded.Unbounded_String); 37 | 38 | procedure Get_Line 39 | (Item : out Strings.Unbounded.Unbounded_String); 40 | 41 | end Ada.Text_IO.Unbounded_IO; 42 | 43 | -------------------------------------------------------------------------------- /ada-task_termination.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Task_Identification; 11 | with Ada.Exceptions; 12 | 13 | package Ada.Task_Termination is 14 | pragma Preelaborate(Task_Termination); 15 | 16 | type Cause_Of_Termination is (Normal, Abnormal, Unhandled_Exception); 17 | 18 | type Termination_Handler is access protected procedure 19 | (Cause : in Cause_Of_Termination; 20 | T : in Ada.Task_Identification.Task_Id; 21 | X : in Ada.Exceptions.Exception_Occurrence); 22 | 23 | procedure Set_Dependents_Fallback_Handler 24 | (Handler: in Termination_Handler); 25 | 26 | function Current_Task_Fallback_Handler return Termination_Handler; 27 | 28 | procedure Set_Specific_Handler 29 | (T : in Ada.Task_Identification.Task_Id; 30 | Handler : in Termination_Handler); 31 | 32 | function Specific_Handler (T : Ada.Task_Identification.Task_Id) 33 | return Termination_Handler; 34 | 35 | end Ada.Task_Termination; 36 | -------------------------------------------------------------------------------- /ada-strings-utf_encoding-wide_wide_strings.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | package Ada.Strings.UTF_Encoding.Wide_Wide_Strings is 10 | pragma Pure (Wide_Wide_Strings); 11 | 12 | -- Encoding / decoding between Wide_Wide_String and various encoding schemes 13 | function Encode (Item : Wide_Wide_String; 14 | Output_Scheme : Encoding_Scheme; 15 | Output_BOM : Boolean := False) return UTF_String; 16 | 17 | function Encode (Item : Wide_Wide_String; 18 | Output_BOM : Boolean := False) return UTF_8_String; 19 | 20 | function Encode (Item : Wide_Wide_String; 21 | Output_BOM : Boolean := False) 22 | return UTF_16_Wide_String; 23 | 24 | function Decode (Item : UTF_String; 25 | Input_Scheme : Encoding_Scheme) return Wide_Wide_String; 26 | 27 | function Decode (Item : UTF_8_String) return Wide_Wide_String; 28 | 29 | function Decode (Item : UTF_16_Wide_String) return Wide_Wide_String; 30 | 31 | end Ada.Strings.UTF_Encoding.Wide_Wide_Strings; 32 | -------------------------------------------------------------------------------- /ada-wide_text_io-bounded_io.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Strings.Wide_Bounded; 11 | 12 | generic 13 | with package Bounded is 14 | new Ada.Strings.Wide_Bounded.Generic_Bounded_Length (<>); 15 | package Ada.Wide_Text_IO.Bounded_IO is 16 | 17 | procedure Put 18 | (File : in File_Type; 19 | Item : in Bounded.Wide_Bounded_String); 20 | 21 | procedure Put 22 | (Item : in Bounded.Wide_Bounded_String); 23 | 24 | procedure Put_Line 25 | (File : in File_Type; 26 | Item : in Bounded.Wide_Bounded_String); 27 | 28 | procedure Put_Line 29 | (Item : in Bounded.Wide_Bounded_String); 30 | 31 | function Get_Line 32 | (File : in File_Type) 33 | return Bounded.Wide_Bounded_String; 34 | 35 | function Get_Line 36 | return Bounded.Wide_Bounded_String; 37 | 38 | procedure Get_Line 39 | (File : in File_Type; Item : out Bounded.Wide_Bounded_String); 40 | 41 | procedure Get_Line 42 | (Item : out Bounded.Wide_Bounded_String); 43 | 44 | end Ada.Wide_Text_IO.Bounded_IO; 45 | -------------------------------------------------------------------------------- /ada-real_time-timing_events.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.Real_Time.Timing_Events is 11 | 12 | type Timing_Event is tagged limited private; 13 | 14 | type Timing_Event_Handler is 15 | access protected procedure (Event : in out Timing_Event); 16 | 17 | procedure Set_Handler (Event : in out Timing_Event; 18 | At_Time : in Time; 19 | Handler : in Timing_Event_Handler); 20 | 21 | procedure Set_Handler (Event : in out Timing_Event; 22 | In_Time : in Time_Span; 23 | Handler : in Timing_Event_Handler); 24 | 25 | function Current_Handler (Event : in Timing_Event) 26 | return Timing_Event_Handler; 27 | 28 | procedure Cancel_Handler (Event : in out Timing_Event; 29 | Cancelled : out Boolean); 30 | 31 | function Time_Of_Event (Event : in Timing_Event) return Time; 32 | 33 | private 34 | 35 | pragma Import (Ada, Timing_Event); 36 | 37 | end Ada.Real_Time.Timing_Events; 38 | -------------------------------------------------------------------------------- /ada-streams.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.Streams is 11 | pragma Pure (Streams); 12 | 13 | type Root_Stream_Type is abstract tagged limited private; 14 | pragma Preelaborable_Initialization (Root_Stream_Type); 15 | 16 | type Stream_Element is mod implementation_defined; 17 | type Stream_Element_Offset is range 18 | implementation_defined .. implementation_defined; 19 | 20 | subtype Stream_Element_Count is 21 | Stream_Element_Offset range 0..Stream_Element_Offset'Last; 22 | 23 | type Stream_Element_Array is 24 | array (Stream_Element_Offset range <>) of aliased Stream_Element; 25 | 26 | procedure Read (Stream : in out Root_Stream_Type; 27 | Item : out Stream_Element_Array; 28 | Last : out Stream_Element_Offset) is abstract; 29 | 30 | procedure Write (Stream : in out Root_Stream_Type; 31 | Item : in Stream_Element_Array) is abstract; 32 | 33 | private 34 | 35 | pragma Import (Ada, Root_Stream_Type); 36 | 37 | end Ada.Streams; 38 | 39 | 40 | 41 | -------------------------------------------------------------------------------- /ada-interrupts.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with System; 11 | 12 | package Ada.Interrupts is 13 | 14 | type Interrupt_ID is (Implementation_Defined); 15 | 16 | type Parameterless_Handler is access protected procedure; 17 | 18 | function Is_Reserved (Interrupt : in Interrupt_ID) return Boolean; 19 | 20 | function Is_Attached (Interrupt : in Interrupt_ID) return Boolean; 21 | 22 | function Current_Handler (Interrupt : in Interrupt_ID) 23 | return Parameterless_Handler; 24 | 25 | procedure Attach_Handler (New_Handler : in Parameterless_Handler; 26 | Interrupt : in Interrupt_ID); 27 | 28 | procedure Exchange_Handler (Old_Handler : out Parameterless_Handler; 29 | New_Handler : in Parameterless_Handler; 30 | Interrupt : in Interrupt_ID); 31 | 32 | procedure Detach_Handler (Interrupt : in Interrupt_ID); 33 | 34 | function Reference (Interrupt : in Interrupt_ID) return System.Address; 35 | 36 | private 37 | 38 | end Ada.Interrupts; 39 | -------------------------------------------------------------------------------- /ada-numerics-discrete_random.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | generic 11 | type Result_Subtype is (<>); 12 | package Ada.Numerics.Discrete_Random is 13 | 14 | -- Basic facilities 15 | 16 | type Generator is limited private; 17 | 18 | function Random (Gen : Generator) return Result_Subtype; 19 | 20 | procedure Reset (Gen : in Generator; 21 | Initiator : in Integer); 22 | procedure Reset (Gen : in Generator); 23 | 24 | -- Advanced facilities 25 | 26 | type State is private; 27 | 28 | procedure Save (Gen : in Generator; 29 | To_State : out State); 30 | procedure Reset (Gen : in Generator; 31 | From_State : in State); 32 | 33 | Max_Image_Width : constant := implementation_defined; 34 | 35 | function Image (Of_State : State) return String; 36 | function Value (Coded_State : String) return State; 37 | 38 | private 39 | 40 | pragma Import (Ada, State); 41 | pragma Import (Ada, Generator); 42 | 43 | end Ada.Numerics.Discrete_Random; 44 | 45 | 46 | 47 | -------------------------------------------------------------------------------- /ada-wide_text_io-unbounded_io.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Strings.Wide_Unbounded; 11 | 12 | package Ada.Wide_Text_IO.Unbounded_IO is 13 | 14 | procedure Put 15 | (File : in File_Type; 16 | Item : in Strings.Wide_Unbounded.Wide_Unbounded_String); 17 | 18 | procedure Put 19 | (Item : in Strings.Wide_Unbounded.Wide_Unbounded_String); 20 | 21 | procedure Put_Line 22 | (File : in File_Type; 23 | Item : in Strings.Wide_Unbounded.Wide_Unbounded_String); 24 | 25 | procedure Put_Line 26 | (Item : in Strings.Wide_Unbounded.Wide_Unbounded_String); 27 | 28 | function Get_Line 29 | (File : in File_Type) 30 | return Strings.Wide_Unbounded.Wide_Unbounded_String; 31 | 32 | function Get_Line 33 | return Strings.Wide_Unbounded.Wide_Unbounded_String; 34 | 35 | procedure Get_Line 36 | (File : in File_Type; 37 | Item : out Strings.Wide_Unbounded.Wide_Unbounded_String); 38 | 39 | procedure Get_Line 40 | (Item : out Strings.Wide_Unbounded.Wide_Unbounded_String); 41 | 42 | end Ada.Wide_Text_IO.Unbounded_IO; 43 | 44 | -------------------------------------------------------------------------------- /ada-tags.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.Tags is 11 | pragma Preelaborate(Tags); 12 | 13 | type Tag is private; 14 | pragma Preelaborable_Initialization(Tag); 15 | 16 | No_Tag : constant Tag; 17 | 18 | function Expanded_Name (T : Tag) return String; 19 | function Wide_Expanded_Name (T : Tag) return Wide_String; 20 | function Wide_Wide_Expanded_Name (T : Tag) return Wide_Wide_String; 21 | 22 | function External_Tag (T : Tag) return String; 23 | function Internal_Tag (External : String) return Tag; 24 | 25 | function Descendant_Tag (External : String; Ancestor : Tag) return Tag; 26 | 27 | function Is_Descendant_At_Same_Level 28 | (Descendant, Ancestor : Tag) 29 | return Boolean; 30 | 31 | function Parent_Tag (T : Tag) return Tag; 32 | 33 | type Tag_Array is array (Positive range <>) of Tag; 34 | 35 | function Interface_Ancestor_Tags (T : Tag) return Tag_Array; 36 | 37 | Tag_Error : exception; 38 | 39 | private 40 | 41 | pragma Import (Ada, Tag); 42 | pragma Import (Ada, No_Tag); 43 | 44 | end Ada.Tags; 45 | 46 | 47 | 48 | -------------------------------------------------------------------------------- /ada-numerics-float_random.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.Numerics.Float_Random is 11 | 12 | -- Basic facilities 13 | 14 | type Generator is limited private; 15 | 16 | subtype Uniformly_Distributed is Float range 0.0 .. 1.0; 17 | function Random (Gen : Generator) return Uniformly_Distributed; 18 | 19 | procedure Reset (Gen : in Generator; 20 | Initiator : in Integer); 21 | procedure Reset (Gen : in Generator); 22 | 23 | -- Advanced facilities 24 | 25 | type State is private; 26 | 27 | procedure Save (Gen : in Generator; 28 | To_State : out State); 29 | procedure Reset (Gen : in Generator; 30 | From_State : in State); 31 | 32 | Max_Image_Width : constant := implementation_defined; 33 | 34 | function Image (Of_State : State) return String; 35 | function Value (Coded_State : String) return State; 36 | 37 | private 38 | 39 | pragma Import (Ada, State); 40 | pragma Import (Ada, Generator); 41 | 42 | end Ada.Numerics.Float_Random; 43 | 44 | 45 | 46 | 47 | -------------------------------------------------------------------------------- /ada-strings-utf_encoding.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | package Ada.Strings.UTF_Encoding is 10 | pragma Pure (UTF_Encoding); 11 | 12 | -- Declarations common to the string encoding packages 13 | type Encoding_Scheme is (UTF_8, UTF_16BE, UTF_16LE); 14 | 15 | subtype UTF_String is String; 16 | 17 | subtype UTF_8_String is String; 18 | 19 | subtype UTF_16_Wide_String is Wide_String; 20 | 21 | Encoding_Error : exception; 22 | 23 | BOM_8 : constant UTF_8_String := 24 | Character'Val(16#EF#) & 25 | Character'Val(16#BB#) & 26 | Character'Val(16#BF#); 27 | 28 | BOM_16BE : constant UTF_String := 29 | Character'Val(16#FE#) & 30 | Character'Val(16#FF#); 31 | 32 | BOM_16LE : constant UTF_String := 33 | Character'Val(16#FF#) & 34 | Character'Val(16#FE#); 35 | 36 | BOM_16 : constant UTF_16_Wide_String := 37 | (1 => Wide_Character'Val(16#FEFF#)); 38 | 39 | function Encoding (Item : UTF_String; 40 | Default : Encoding_Scheme := UTF_8) 41 | return Encoding_Scheme; 42 | 43 | end Ada.Strings.UTF_Encoding; 44 | -------------------------------------------------------------------------------- /ada-wide_wide_text_io-wide_wide_bounded_io.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Strings.Wide_Wide_Bounded; 11 | 12 | generic 13 | with package Bounded is 14 | new Ada.Strings.Wide_Wide_Bounded.Generic_Bounded_Length (<>); 15 | package Ada.Wide_Wide_Text_IO.Wide_Wide_Bounded_IO is 16 | 17 | procedure Put 18 | (File : in File_Type; 19 | Item : in Bounded.Wide_Wide_Bounded_String); 20 | 21 | procedure Put 22 | (Item : in Bounded.Wide_Wide_Bounded_String); 23 | 24 | procedure Put_Line 25 | (File : in File_Type; 26 | Item : in Bounded.Wide_Wide_Bounded_String); 27 | 28 | procedure Put_Line 29 | (Item : in Bounded.Wide_Wide_Bounded_String); 30 | 31 | function Get_Line 32 | (File : in File_Type) 33 | return Bounded.Wide_Wide_Bounded_String; 34 | 35 | function Get_Line 36 | return Bounded.Wide_Wide_Bounded_String; 37 | 38 | procedure Get_Line 39 | (File : in File_Type; Item : out Bounded.Wide_Wide_Bounded_String); 40 | 41 | procedure Get_Line 42 | (Item : out Bounded.Wide_Wide_Bounded_String); 43 | 44 | end Ada.Wide_Wide_Text_IO.Wide_Wide_Bounded_IO; 45 | -------------------------------------------------------------------------------- /LICENSES/BSD-3-Clause.txt: -------------------------------------------------------------------------------- 1 | Copyright (c) 2006-2018, Maxim Reznik 2 | All rights reserved. 3 | 4 | Redistribution and use in source and binary forms, with or without 5 | modification, are permitted provided that the following conditions are met: 6 | 7 | * Redistributions of source code must retain the above copyright notice, 8 | this list of conditions and the following disclaimer. 9 | * Redistributions in binary form must reproduce the above copyright 10 | notice, this list of conditions and the following disclaimer in the 11 | documentation and/or other materials provided with the distribution. 12 | * Neither the name of the Maxim Reznik, IE nor the names of its 13 | contributors may be used to endorse or promote products derived from 14 | this software without specific prior written permission. 15 | 16 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 17 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 | ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 20 | LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21 | CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22 | SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 23 | INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 24 | CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 25 | ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 26 | POSSIBILITY OF SUCH DAMAGE. 27 | -------------------------------------------------------------------------------- /ada-directories-hierarchical_file_names.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | 10 | package Ada.Directories.Hierarchical_File_Names is 11 | 12 | function Is_Simple_Name (Name : in String) return Boolean; 13 | 14 | function Is_Root_Directory_Name (Name : in String) return Boolean; 15 | 16 | function Is_Parent_Directory_Name (Name : in String) return Boolean; 17 | 18 | function Is_Current_Directory_Name (Name : in String) return Boolean; 19 | 20 | function Is_Full_Name (Name : in String) return Boolean; 21 | 22 | function Is_Relative_Name (Name : in String) return Boolean; 23 | 24 | function Simple_Name (Name : in String) return String 25 | renames Ada.Directories.Simple_Name; 26 | 27 | function Containing_Directory (Name : in String) return String 28 | renames Ada.Directories.Containing_Directory; 29 | 30 | function Initial_Directory (Name : in String) return String; 31 | 32 | function Relative_Name (Name : in String) return String; 33 | 34 | function Compose (Directory : in String := ""; 35 | Relative_Name : in String; 36 | Extension : in String := "") return String; 37 | 38 | end Ada.Directories.Hierarchical_File_Names; 39 | -------------------------------------------------------------------------------- /ada-strings-utf_encoding-conversions.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | package Ada.Strings.UTF_Encoding.Conversions is 10 | pragma Pure (Conversions); 11 | 12 | -- Conversions between various encoding schemes 13 | function Convert (Item : UTF_String; 14 | Input_Scheme : Encoding_Scheme; 15 | Output_Scheme : Encoding_Scheme; 16 | Output_BOM : Boolean := False) return UTF_String; 17 | 18 | function Convert (Item : UTF_String; 19 | Input_Scheme : Encoding_Scheme; 20 | Output_BOM : Boolean := False) 21 | return UTF_16_Wide_String; 22 | 23 | function Convert (Item : UTF_8_String; 24 | Output_BOM : Boolean := False) 25 | return UTF_16_Wide_String; 26 | 27 | function Convert (Item : UTF_16_Wide_String; 28 | Output_Scheme : Encoding_Scheme; 29 | Output_BOM : Boolean := False) return UTF_String; 30 | 31 | function Convert (Item : UTF_16_Wide_String; 32 | Output_BOM : Boolean := False) return UTF_8_String; 33 | 34 | end Ada.Strings.UTF_Encoding.Conversions; 35 | -------------------------------------------------------------------------------- /ada-calendar-arithmetic.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.Calendar.Arithmetic is 11 | 12 | -- Arithmetic on days: 13 | 14 | type Day_Count is 15 | range -366 * (1 + Year_Number'Last - Year_Number'First) 16 | .. 366 * (1 + Year_Number'Last - Year_Number'First); 17 | 18 | subtype Leap_Seconds_Count is Integer range -2047 .. 2047; 19 | 20 | procedure Difference (Left : in Time; 21 | Right : in Time; 22 | Days : out Day_Count; 23 | Seconds : out Duration; 24 | Leap_Seconds : out Leap_Seconds_Count); 25 | 26 | function "+" (Left : in Time; 27 | Right : in Day_Count) 28 | return Time; 29 | 30 | function "+" (Left : in Day_Count; 31 | Right : in Time) 32 | return Time; 33 | 34 | function "-" (Left : in Time; 35 | Right : in Day_Count) 36 | return Time; 37 | 38 | function "-" (Left : in Time; 39 | Right : in Time) 40 | return Day_Count; 41 | 42 | end Ada.Calendar.Arithmetic; 43 | -------------------------------------------------------------------------------- /ada-containers-unbounded_synchronized_queues.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | with System; 10 | with Ada.Containers.Synchronized_Queue_Interfaces; 11 | generic 12 | with package Queue_Interfaces is new Ada.Containers.Synchronized_Queue_Interfaces (<>); 13 | Default_Ceiling : System.Any_Priority := System.Priority'Last; 14 | package Ada.Containers.Unbounded_Synchronized_Queues is 15 | pragma Preelaborate(Unbounded_Synchronized_Queues); 16 | 17 | package Implementation is 18 | -- not specified by the language 19 | end Implementation; 20 | 21 | protected type Queue 22 | (Ceiling : System.Any_Priority := Default_Ceiling) 23 | with Priority => Ceiling is 24 | new Queue_Interfaces.Queue with 25 | 26 | overriding 27 | entry Enqueue (New_Item : in Queue_Interfaces.Element_Type); 28 | overriding 29 | entry Dequeue (Element : out Queue_Interfaces.Element_Type); 30 | 31 | overriding 32 | function Current_Use return Count_Type; 33 | overriding 34 | function Peak_Use return Count_Type; 35 | 36 | private 37 | -- not specified by the language 38 | end Queue; 39 | 40 | private 41 | 42 | -- not specified by the language 43 | 44 | end Ada.Containers.Unbounded_Synchronized_Queues; 45 | -------------------------------------------------------------------------------- /ada-wide_wide_text_io-wide_wide_unbounded_io.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Strings.Wide_Wide_Unbounded; 11 | 12 | package Ada.Wide_Wide_Text_IO.Wide_Wide_Unbounded_IO is 13 | 14 | procedure Put 15 | (File : in File_Type; 16 | Item : in Strings.Wide_Wide_Unbounded.Wide_Wide_Unbounded_String); 17 | 18 | procedure Put 19 | (Item : in Strings.Wide_Wide_Unbounded.Wide_Wide_Unbounded_String); 20 | 21 | procedure Put_Line 22 | (File : in File_Type; 23 | Item : in Strings.Wide_Wide_Unbounded.Wide_Wide_Unbounded_String); 24 | 25 | procedure Put_Line 26 | (Item : in Strings.Wide_Wide_Unbounded.Wide_Wide_Unbounded_String); 27 | 28 | function Get_Line 29 | (File : in File_Type) 30 | return Strings.Wide_Wide_Unbounded.Wide_Wide_Unbounded_String; 31 | 32 | function Get_Line 33 | return Strings.Wide_Wide_Unbounded.Wide_Wide_Unbounded_String; 34 | 35 | procedure Get_Line 36 | (File : in File_Type; 37 | Item : out Strings.Wide_Wide_Unbounded.Wide_Wide_Unbounded_String); 38 | 39 | procedure Get_Line 40 | (Item : out Strings.Wide_Wide_Unbounded.Wide_Wide_Unbounded_String); 41 | 42 | end Ada.Wide_Wide_Text_IO.Wide_Wide_Unbounded_IO; 43 | 44 | -------------------------------------------------------------------------------- /ada-execution_time-timers.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with System; 11 | 12 | package Ada.Execution_Time.Timers is 13 | 14 | type Timer (T : not null access constant Ada.Task_Identification.Task_Id) is 15 | tagged limited private; 16 | 17 | type Timer_Handler is access protected procedure (TM : in out Timer); 18 | 19 | Min_Handler_Ceiling : constant System.Any_Priority := 20 | implementation_defined; 21 | 22 | procedure Set_Handler (TM : in out Timer; 23 | In_Time : in Ada.Real_Time.Time_Span; 24 | Handler : in Timer_Handler); 25 | 26 | procedure Set_Handler (TM : in out Timer; 27 | At_Time : in CPU_Time; 28 | Handler : in Timer_Handler); 29 | 30 | function Current_Handler (TM : Timer) return Timer_Handler; 31 | 32 | procedure Cancel_Handler (TM : in out Timer; 33 | Cancelled : out Boolean); 34 | 35 | function Time_Remaining (TM : Timer) return Ada.Real_Time.Time_Span; 36 | 37 | Timer_Resource_Error : exception; 38 | 39 | private 40 | 41 | pragma Import (Ada, Timer); 42 | 43 | end Ada.Execution_Time.Timers; 44 | -------------------------------------------------------------------------------- /system-storage_pools.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Finalization; 11 | with System.Storage_Elements; 12 | 13 | package System.Storage_Pools is 14 | pragma Preelaborate (System.Storage_Pools); 15 | 16 | type Root_Storage_Pool is 17 | abstract new Ada.Finalization.Limited_Controlled with private; 18 | pragma Preelaborable_Initialization (Root_Storage_Pool); 19 | 20 | procedure Allocate 21 | (Pool : in out Root_Storage_Pool; 22 | Storage_Address : out Address; 23 | Size_In_Storage_Elements : in Storage_Elements.Storage_Count; 24 | Alignment : in Storage_Elements.Storage_Count) 25 | is abstract; 26 | 27 | procedure Deallocate 28 | (Pool : in out Root_Storage_Pool; 29 | Storage_Address : in Address; 30 | Size_In_Storage_Elements : in Storage_Elements.Storage_Count; 31 | Alignment : in Storage_Elements.Storage_Count) 32 | is abstract; 33 | 34 | function Storage_Size 35 | (Pool : Root_Storage_Pool) 36 | return Storage_Elements.Storage_Count 37 | is abstract; 38 | 39 | private 40 | 41 | pragma Import (Ada, Root_Storage_Pool); 42 | 43 | end System.Storage_Pools; 44 | 45 | 46 | 47 | -------------------------------------------------------------------------------- /ada-containers-bounded_synchronized_queues.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | with System; 10 | with Ada.Containers.Synchronized_Queue_Interfaces; 11 | generic 12 | with package Queue_Interfaces is new Ada.Containers.Synchronized_Queue_Interfaces (<>); 13 | Default_Capacity : Count_Type; 14 | Default_Ceiling : System.Any_Priority := System.Priority'Last; 15 | package Ada.Containers.Bounded_Synchronized_Queues is 16 | pragma Preelaborate(Bounded_Synchronized_Queues); 17 | 18 | package Implementation is 19 | -- not specified by the language 20 | end Implementation; 21 | 22 | protected type Queue 23 | (Capacity : Count_Type := Default_Capacity; 24 | Ceiling : System.Any_Priority := Default_Ceiling) 25 | with Priority => Ceiling is 26 | new Queue_Interfaces.Queue with 27 | 28 | overriding 29 | entry Enqueue (New_Item : in Queue_Interfaces.Element_Type); 30 | overriding 31 | entry Dequeue (Element : out Queue_Interfaces.Element_Type); 32 | 33 | overriding 34 | function Current_Use return Count_Type; 35 | overriding 36 | function Peak_Use return Count_Type; 37 | 38 | private 39 | -- not specified by the language 40 | end Queue; 41 | 42 | private 43 | 44 | -- not specified by the language 45 | 46 | end Ada.Containers.Bounded_Synchronized_Queues; 47 | -------------------------------------------------------------------------------- /ada-text_io-complex_io.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Numerics.Generic_Complex_Types; 11 | 12 | generic 13 | with package Complex_Types is 14 | new Ada.Numerics.Generic_Complex_Types (<>); 15 | package Ada.Text_IO.Complex_IO is 16 | 17 | use Complex_Types; 18 | 19 | Default_Fore : Field := 2; 20 | Default_Aft : Field := Real'Digits - 1; 21 | Default_Exp : Field := 3; 22 | 23 | procedure Get (File : in File_Type; 24 | Item : out Complex; 25 | Width : in Field := 0); 26 | 27 | procedure Get (Item : out Complex; 28 | Width : in Field := 0); 29 | 30 | procedure Put (File : in File_Type; 31 | Item : in Complex; 32 | Fore : in Field := Default_Fore; 33 | Aft : in Field := Default_Aft; 34 | Exp : in Field := Default_Exp); 35 | 36 | procedure Put (Item : in Complex; 37 | Fore : in Field := Default_Fore; 38 | Aft : in Field := Default_Aft; 39 | Exp : in Field := Default_Exp); 40 | 41 | procedure Get (From : in String; 42 | Item : out Complex; 43 | Last : out Positive); 44 | 45 | procedure Put (To : out String; 46 | Item : in Complex; 47 | Aft : in Field := Default_Aft; 48 | Exp : in Field := Default_Exp); 49 | 50 | end Ada.Text_IO.Complex_IO; 51 | -------------------------------------------------------------------------------- /ada-wide_text_io-complex_io.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Numerics.Generic_Complex_Types; 11 | 12 | generic 13 | with package Complex_Types is 14 | new Ada.Numerics.Generic_Complex_Types (<>); 15 | package Ada.Wide_Text_IO.Complex_IO is 16 | 17 | use Complex_Types; 18 | 19 | Default_Fore : Field := 2; 20 | Default_Aft : Field := Real'Digits - 1; 21 | Default_Exp : Field := 3; 22 | 23 | procedure Get (File : in File_Type; 24 | Item : out Complex; 25 | Width : in Field := 0); 26 | 27 | procedure Get (Item : out Complex; 28 | Width : in Field := 0); 29 | 30 | procedure Put (File : in File_Type; 31 | Item : in Complex; 32 | Fore : in Field := Default_Fore; 33 | Aft : in Field := Default_Aft; 34 | Exp : in Field := Default_Exp); 35 | 36 | procedure Put (Item : in Complex; 37 | Fore : in Field := Default_Fore; 38 | Aft : in Field := Default_Aft; 39 | Exp : in Field := Default_Exp); 40 | 41 | procedure Get (From : in Wide_String; 42 | Item : out Complex; 43 | Last : out Positive); 44 | 45 | procedure Put (To : out Wide_String; 46 | Item : in Complex; 47 | Aft : in Field := Default_Aft; 48 | Exp : in Field := Default_Exp); 49 | 50 | end Ada.Wide_Text_IO.Complex_IO; 51 | -------------------------------------------------------------------------------- /ada-wide_wide_text_io-complex_io.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Numerics.Generic_Complex_Types; 11 | 12 | generic 13 | with package Complex_Types is 14 | new Ada.Numerics.Generic_Complex_Types (<>); 15 | package Ada.Wide_Wide_Text_IO.Complex_IO is 16 | 17 | use Complex_Types; 18 | 19 | Default_Fore : Field := 2; 20 | Default_Aft : Field := Real'Digits - 1; 21 | Default_Exp : Field := 3; 22 | 23 | procedure Get (File : in File_Type; 24 | Item : out Complex; 25 | Width : in Field := 0); 26 | 27 | procedure Get (Item : out Complex; 28 | Width : in Field := 0); 29 | 30 | procedure Put (File : in File_Type; 31 | Item : in Complex; 32 | Fore : in Field := Default_Fore; 33 | Aft : in Field := Default_Aft; 34 | Exp : in Field := Default_Exp); 35 | 36 | procedure Put (Item : in Complex; 37 | Fore : in Field := Default_Fore; 38 | Aft : in Field := Default_Aft; 39 | Exp : in Field := Default_Exp); 40 | 41 | procedure Get (From : in Wide_Wide_String; 42 | Item : out Complex; 43 | Last : out Positive); 44 | 45 | procedure Put (To : out Wide_Wide_String; 46 | Item : in Complex; 47 | Aft : in Field := Default_Aft; 48 | Exp : in Field := Default_Exp); 49 | 50 | end Ada.Wide_Wide_Text_IO.Complex_IO; 51 | -------------------------------------------------------------------------------- /system-rpc.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Streams; -- see 13.13.1 11 | 12 | package System.RPC is 13 | 14 | type Partition_Id is range 0 .. implementation_defined; 15 | 16 | Communication_Error : exception; 17 | 18 | type Params_Stream_Type (Initial_Size : Ada.Streams.Stream_Element_Count) is 19 | new Ada.Streams.Root_Stream_Type with private; 20 | 21 | procedure Read (Stream : in out Params_Stream_Type; 22 | Item : out Ada.Streams.Stream_Element_Array; 23 | Last : out Ada.Streams.Stream_Element_Offset); 24 | 25 | procedure Write (Stream : in out Params_Stream_Type; 26 | Item : in Ada.Streams.Stream_Element_Array); 27 | 28 | -- Synchronous call 29 | 30 | procedure Do_RPC (Partition : in Partition_Id; 31 | Params : access Params_Stream_Type; 32 | Result : access Params_Stream_Type); 33 | 34 | -- Asynchronous call 35 | 36 | procedure Do_APC (Partition : in Partition_Id; 37 | Params : access Params_Stream_Type); 38 | 39 | -- The handler for incoming RPCs 40 | 41 | type RPC_Receiver is access procedure (Params : access Params_Stream_Type; 42 | Result : access Params_Stream_Type); 43 | 44 | procedure Establish_RPC_Receiver (Partition : in Partition_Id; 45 | Receiver : in RPC_Receiver); 46 | 47 | private 48 | 49 | pragma Import (Ada, Params_Stream_Type); 50 | 51 | end System.RPC; 52 | -------------------------------------------------------------------------------- /ada-wide_characters-handling.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | package Ada.Wide_Characters.Handling is 10 | pragma Pure(Handling); 11 | 12 | function Character_Set_Version return String; 13 | 14 | function Is_Control (Item : Wide_Character) return Boolean; 15 | 16 | function Is_Letter (Item : Wide_Character) return Boolean; 17 | 18 | function Is_Lower (Item : Wide_Character) return Boolean; 19 | 20 | function Is_Upper (Item : Wide_Character) return Boolean; 21 | 22 | function Is_Digit (Item : Wide_Character) return Boolean; 23 | 24 | function Is_Decimal_Digit (Item : Wide_Character) return Boolean 25 | renames Is_Digit; 26 | 27 | function Is_Hexadecimal_Digit (Item : Wide_Character) return Boolean; 28 | 29 | function Is_Alphanumeric (Item : Wide_Character) return Boolean; 30 | 31 | function Is_Special (Item : Wide_Character) return Boolean; 32 | 33 | function Is_Line_Terminator (Item : Wide_Character) return Boolean; 34 | 35 | function Is_Mark (Item : Wide_Character) return Boolean; 36 | 37 | function Is_Other_Format (Item : Wide_Character) return Boolean; 38 | 39 | function Is_Punctuation_Connector (Item : Wide_Character) return Boolean; 40 | 41 | function Is_Space (Item : Wide_Character) return Boolean; 42 | 43 | function Is_Graphic (Item : Wide_Character) return Boolean; 44 | 45 | function To_Lower (Item : Wide_Character) return Wide_Character; 46 | function To_Upper (Item : Wide_Character) return Wide_Character; 47 | 48 | function To_Lower (Item : Wide_String) return Wide_String; 49 | function To_Upper (Item : Wide_String) return Wide_String; 50 | 51 | end Ada.Wide_Characters.Handling; 52 | 53 | -------------------------------------------------------------------------------- /ada-containers-unbounded_priority_queues.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | with System; 10 | with Ada.Containers.Synchronized_Queue_Interfaces; 11 | generic 12 | with package Queue_Interfaces is new Ada.Containers.Synchronized_Queue_Interfaces (<>); 13 | type Queue_Priority is private; 14 | with function Get_Priority 15 | (Element : Queue_Interfaces.Element_Type) return Queue_Priority is <>; 16 | with function Before 17 | (Left, Right : Queue_Priority) return Boolean is <>; 18 | Default_Ceiling : System.Any_Priority := System.Priority'Last; 19 | package Ada.Containers.Unbounded_Priority_Queues is 20 | pragma Preelaborate(Unbounded_Priority_Queues); 21 | 22 | package Implementation is 23 | -- not specified by the language 24 | end Implementation; 25 | 26 | protected type Queue 27 | (Ceiling : System.Any_Priority := Default_Ceiling) 28 | with Priority => Ceiling is 29 | new Queue_Interfaces.Queue with 30 | 31 | overriding 32 | entry Enqueue (New_Item : in Queue_Interfaces.Element_Type); 33 | overriding 34 | entry Dequeue (Element : out Queue_Interfaces.Element_Type); 35 | 36 | not overriding 37 | procedure Dequeue_Only_High_Priority 38 | (At_Least : in Queue_Priority; 39 | Element : in out Queue_Interfaces.Element_Type; 40 | Success : out Boolean); 41 | 42 | overriding 43 | function Current_Use return Count_Type; 44 | overriding 45 | function Peak_Use return Count_Type; 46 | 47 | private 48 | -- not specified by the language 49 | end Queue; 50 | 51 | private 52 | 53 | -- not specified by the language 54 | 55 | end Ada.Containers.Unbounded_Priority_Queues; 56 | -------------------------------------------------------------------------------- /ada-wide_wide_characters-handling.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | package Ada.Wide_Wide_Characters.Handling is 10 | pragma Pure(Handling); 11 | 12 | function Character_Set_Version return String; 13 | 14 | function Is_Control (Item : Wide_Wide_Character) return Boolean; 15 | 16 | function Is_Letter (Item : Wide_Wide_Character) return Boolean; 17 | 18 | function Is_Lower (Item : Wide_Wide_Character) return Boolean; 19 | 20 | function Is_Upper (Item : Wide_Wide_Character) return Boolean; 21 | 22 | function Is_Digit (Item : Wide_Wide_Character) return Boolean; 23 | 24 | function Is_Decimal_Digit (Item : Wide_Wide_Character) return Boolean 25 | renames Is_Digit; 26 | 27 | function Is_Hexadecimal_Digit (Item : Wide_Wide_Character) return Boolean; 28 | 29 | function Is_Alphanumeric (Item : Wide_Wide_Character) return Boolean; 30 | 31 | function Is_Special (Item : Wide_Wide_Character) return Boolean; 32 | 33 | function Is_Line_Terminator (Item : Wide_Wide_Character) return Boolean; 34 | 35 | function Is_Mark (Item : Wide_Wide_Character) return Boolean; 36 | 37 | function Is_Other_Format (Item : Wide_Wide_Character) return Boolean; 38 | 39 | function Is_Punctuation_Connector (Item : Wide_Wide_Character) return Boolean; 40 | 41 | function Is_Space (Item : Wide_Wide_Character) return Boolean; 42 | 43 | function Is_Graphic (Item : Wide_Wide_Character) return Boolean; 44 | 45 | function To_Lower (Item : Wide_Wide_Character) return Wide_Wide_Character; 46 | function To_Upper (Item : Wide_Wide_Character) return Wide_Wide_Character; 47 | 48 | function To_Lower (Item : Wide_Wide_String) return Wide_Wide_String; 49 | function To_Upper (Item : Wide_Wide_String) return Wide_Wide_String; 50 | 51 | end Ada.Wide_Wide_Characters.Handling; 52 | 53 | -------------------------------------------------------------------------------- /ada-calendar.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.Calendar is 11 | type Time is private; 12 | 13 | subtype Year_Number is Integer range 1901 .. 2399; 14 | subtype Month_Number is Integer range 1 .. 12; 15 | subtype Day_Number is Integer range 1 .. 31; 16 | subtype Day_Duration is Duration range 0.0 .. 86_400.0; 17 | 18 | function Clock return Time; 19 | 20 | function Year (Date : Time) return Year_Number; 21 | function Month (Date : Time) return Month_Number; 22 | function Day (Date : Time) return Day_Number; 23 | function Seconds(Date : Time) return Day_Duration; 24 | 25 | procedure Split (Date : in Time; 26 | Year : out Year_Number; 27 | Month : out Month_Number; 28 | Day : out Day_Number; 29 | Seconds : out Day_Duration); 30 | 31 | function Time_Of(Year : Year_Number; 32 | Month : Month_Number; 33 | Day : Day_Number; 34 | Seconds : Day_Duration := 0.0) 35 | return Time; 36 | 37 | function "+" (Left : Time; Right : Duration) return Time; 38 | function "+" (Left : Duration; Right : Time) return Time; 39 | function "-" (Left : Time; Right : Duration) return Time; 40 | function "-" (Left : Time; Right : Time) return Duration; 41 | 42 | function "<" (Left, Right : Time) return Boolean; 43 | function "<="(Left, Right : Time) return Boolean; 44 | function ">" (Left, Right : Time) return Boolean; 45 | function ">="(Left, Right : Time) return Boolean; 46 | 47 | Time_Error : exception; 48 | 49 | private 50 | 51 | pragma Import (Ada, Time); 52 | 53 | end Ada.Calendar; 54 | 55 | 56 | 57 | -------------------------------------------------------------------------------- /system-storage_elements.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package System.Storage_Elements is 11 | pragma Pure (System.Storage_Elements); 12 | 13 | type Storage_Offset is 14 | range implementation_defined .. implementation_defined; 15 | 16 | subtype Storage_Count is Storage_Offset range 0 .. Storage_Offset'Last; 17 | 18 | type Storage_Element is mod implementation_defined; 19 | for Storage_Element'Size use Storage_Unit; 20 | 21 | type Storage_Array is array 22 | (Storage_Offset range <>) of aliased Storage_Element; 23 | for Storage_Array'Component_Size use Storage_Unit; 24 | 25 | -- Address Arithmetic: 26 | 27 | function "+" (Left : Address; Right : Storage_Offset) 28 | return Address; 29 | function "+" (Left : Storage_Offset; Right : Address) 30 | return Address; 31 | function "-" (Left : Address; Right : Storage_Offset) 32 | return Address; 33 | function "-" (Left, Right : Address) 34 | return Storage_Offset; 35 | 36 | function "mod" (Left : Address; Right : Storage_Offset) 37 | return Storage_Offset; 38 | 39 | -- Conversion to/from integers: 40 | 41 | type Integer_Address is mod implementation_defined; 42 | function To_Address (Value : Integer_Address) return Address; 43 | function To_Integer (Value : Address) return Integer_Address; 44 | 45 | pragma Convention (Intrinsic, "+"); 46 | pragma Convention (Intrinsic, "-"); 47 | pragma Convention (Intrinsic, "mod"); 48 | pragma Convention (Intrinsic, "To_Address"); 49 | pragma Convention (Intrinsic, "To_Integer"); 50 | -- and so on for all language-defined subprograms declared in this package. 51 | end System.Storage_Elements; 52 | 53 | 54 | 55 | -------------------------------------------------------------------------------- /ada-containers-bounded_priority_queues.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | with System; 10 | with Ada.Containers.Synchronized_Queue_Interfaces; 11 | generic 12 | with package Queue_Interfaces is new Ada.Containers.Synchronized_Queue_Interfaces (<>); 13 | type Queue_Priority is private; 14 | with function Get_Priority 15 | (Element : Queue_Interfaces.Element_Type) return Queue_Priority is <>; 16 | with function Before 17 | (Left, Right : Queue_Priority) return Boolean is <>; 18 | Default_Capacity : Count_Type; 19 | Default_Ceiling : System.Any_Priority := System.Priority'Last; 20 | package Ada.Containers.Bounded_Priority_Queues is 21 | pragma Preelaborate(Bounded_Priority_Queues); 22 | 23 | package Implementation is 24 | -- not specified by the language 25 | end Implementation; 26 | 27 | protected type Queue 28 | (Capacity : Count_Type := Default_Capacity; 29 | Ceiling : System.Any_Priority := Default_Ceiling) 30 | with Priority => Ceiling is 31 | new Queue_Interfaces.Queue with 32 | 33 | overriding 34 | entry Enqueue (New_Item : in Queue_Interfaces.Element_Type); 35 | overriding 36 | entry Dequeue (Element : out Queue_Interfaces.Element_Type); 37 | 38 | not overriding 39 | procedure Dequeue_Only_High_Priority 40 | (At_Least : in Queue_Priority; 41 | Element : in out Queue_Interfaces.Element_Type; 42 | Success : out Boolean); 43 | 44 | overriding 45 | function Current_Use return Count_Type; 46 | overriding 47 | function Peak_Use return Count_Type; 48 | 49 | private 50 | -- not specified by the language 51 | end Queue; 52 | 53 | private 54 | 55 | -- not specified by the language 56 | 57 | end Ada.Containers.Bounded_Priority_Queues; 58 | -------------------------------------------------------------------------------- /ada-strings-maps-constants.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.Strings.Maps.Constants is 11 | pragma Pure (Constants); 12 | 13 | Control_Set : constant Character_Set; 14 | Graphic_Set : constant Character_Set; 15 | Letter_Set : constant Character_Set; 16 | Lower_Set : constant Character_Set; 17 | Upper_Set : constant Character_Set; 18 | Basic_Set : constant Character_Set; 19 | Decimal_Digit_Set : constant Character_Set; 20 | Hexadecimal_Digit_Set : constant Character_Set; 21 | Alphanumeric_Set : constant Character_Set; 22 | Special_Set : constant Character_Set; 23 | ISO_646_Set : constant Character_Set; 24 | 25 | Lower_Case_Map : constant Character_Mapping; 26 | --Maps to lower case for letters, else identity 27 | Upper_Case_Map : constant Character_Mapping; 28 | --Maps to upper case for letters, else identity 29 | Basic_Map : constant Character_Mapping; 30 | --Maps to basic letter for letters, else identity 31 | 32 | private 33 | 34 | pragma Import (Ada, Control_Set); 35 | pragma Import (Ada, Graphic_Set); 36 | pragma Import (Ada, Letter_Set); 37 | pragma Import (Ada, Lower_Set); 38 | pragma Import (Ada, Upper_Set); 39 | pragma Import (Ada, Basic_Set); 40 | pragma Import (Ada, Decimal_Digit_Set); 41 | pragma Import (Ada, Hexadecimal_Digit_Set); 42 | pragma Import (Ada, Alphanumeric_Set); 43 | pragma Import (Ada, Special_Set); 44 | pragma Import (Ada, ISO_646_Set); 45 | 46 | pragma Import (Ada, Lower_Case_Map); 47 | pragma Import (Ada, Upper_Case_Map); 48 | pragma Import (Ada, Basic_Map); 49 | 50 | end Ada.Strings.Maps.Constants; 51 | 52 | 53 | 54 | -------------------------------------------------------------------------------- /system-multiprocessors-dispatching_domains.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | with Ada.Real_Time; 10 | with Ada.Task_Identification; 11 | package System.Multiprocessors.Dispatching_Domains is 12 | 13 | Dispatching_Domain_Error : exception; 14 | 15 | type Dispatching_Domain (<>) is limited private; 16 | 17 | System_Dispatching_Domain : constant Dispatching_Domain; 18 | 19 | function Create (First : CPU; Last : CPU_Range) return Dispatching_Domain; 20 | 21 | function Get_First_CPU (Domain : Dispatching_Domain) return CPU; 22 | 23 | function Get_Last_CPU (Domain : Dispatching_Domain) return CPU_Range; 24 | 25 | type CPU_Set is array(CPU range <>) of Boolean; 26 | 27 | function Create (Set : CPU_Set) return Dispatching_Domain; 28 | 29 | function Get_CPU_Set (Domain : Dispatching_Domain) return CPU_Set; 30 | 31 | function Get_Dispatching_Domain 32 | (T : Ada.Task_Identification.Task_Id := 33 | Ada.Task_Identification.Current_Task) 34 | return Dispatching_Domain; 35 | 36 | procedure Assign_Task 37 | (Domain : in out Dispatching_Domain; 38 | CPU : in CPU_Range := Not_A_Specific_CPU; 39 | T : in Ada.Task_Identification.Task_Id := 40 | Ada.Task_Identification.Current_Task); 41 | 42 | procedure Set_CPU 43 | (CPU : in CPU_Range; 44 | T : in Ada.Task_Identification.Task_Id := 45 | Ada.Task_Identification.Current_Task); 46 | 47 | function Get_CPU 48 | (T : Ada.Task_Identification.Task_Id := 49 | Ada.Task_Identification.Current_Task) 50 | return CPU_Range; 51 | 52 | procedure Delay_Until_And_Set_CPU 53 | (Delay_Until_Time : in Ada.Real_Time.Time; CPU : in CPU_Range); 54 | 55 | private 56 | -- not specified by the language 57 | end System.Multiprocessors.Dispatching_Domains; 58 | -------------------------------------------------------------------------------- /interfaces-c-strings.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Interfaces.C.Strings is 11 | pragma Preelaborate (Strings); 12 | 13 | type char_array_access is access all char_array; 14 | 15 | type chars_ptr is private; 16 | pragma Preelaborable_Initialization (chars_ptr); 17 | 18 | type chars_ptr_array is array (size_t range <>) of aliased chars_ptr; 19 | 20 | Null_Ptr : constant chars_ptr; 21 | 22 | function To_Chars_Ptr (Item : in char_array_access; 23 | Nul_Check : in Boolean := False) 24 | return chars_ptr; 25 | 26 | function New_Char_Array (Chars : in char_array) return chars_ptr; 27 | 28 | function New_String (Str : in String) return chars_ptr; 29 | 30 | procedure Free (Item : in out chars_ptr); 31 | 32 | Dereference_Error : exception; 33 | 34 | function Value (Item : in chars_ptr) return char_array; 35 | 36 | function Value (Item : in chars_ptr; Length : in size_t) 37 | return char_array; 38 | 39 | function Value (Item : in chars_ptr) return String; 40 | 41 | function Value (Item : in chars_ptr; Length : in size_t) 42 | return String; 43 | 44 | function Strlen (Item : in chars_ptr) return size_t; 45 | 46 | procedure Update (Item : in chars_ptr; 47 | Offset : in size_t; 48 | Chars : in char_array; 49 | Check : in Boolean := True); 50 | 51 | procedure Update (Item : in chars_ptr; 52 | Offset : in size_t; 53 | Str : in String; 54 | Check : in Boolean := True); 55 | 56 | Update_Error : exception; 57 | 58 | private 59 | pragma Import (Ada, chars_ptr); 60 | pragma Import (Ada, Null_Ptr); 61 | end Interfaces.C.Strings; 62 | 63 | 64 | 65 | -------------------------------------------------------------------------------- /ada-containers-indefinite_holders.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | generic 10 | type Element_Type (<>) is private; 11 | with function "=" (Left, Right : Element_Type) return Boolean is <>; 12 | package Ada.Containers.Indefinite_Holders is 13 | pragma Preelaborate(Indefinite_Holders); 14 | pragma Remote_Types(Indefinite_Holders); 15 | 16 | type Holder is tagged private; 17 | pragma Preelaborable_Initialization (Holder); 18 | 19 | Empty_Holder : constant Holder; 20 | 21 | function "=" (Left, Right : Holder) return Boolean; 22 | 23 | function To_Holder (New_Item : Element_Type) return Holder; 24 | 25 | function Is_Empty (Container : Holder) return Boolean; 26 | 27 | procedure Clear (Container : in out Holder); 28 | 29 | function Element (Container : Holder) return Element_Type; 30 | 31 | procedure Replace_Element (Container : in out Holder; 32 | New_Item : in Element_Type); 33 | 34 | procedure Query_Element 35 | (Container : in Holder; 36 | Process : not null access procedure (Element : in Element_Type)); 37 | 38 | procedure Update_Element 39 | (Container : in out Holder; 40 | Process : not null access procedure (Element : in out Element_Type)); 41 | 42 | type Constant_Reference_Type 43 | (Element : not null access constant Element_Type) is private 44 | with Implicit_Dereference => Element; 45 | 46 | type Reference_Type (Element : not null access Element_Type) is private 47 | with Implicit_Dereference => Element; 48 | 49 | function Constant_Reference (Container : aliased in Holder) 50 | return Constant_Reference_Type; 51 | 52 | function Reference (Container : aliased in out Holder) 53 | return Reference_Type; 54 | 55 | procedure Assign (Target : in out Holder; Source : in Holder); 56 | 57 | function Copy (Source : Holder) return Holder; 58 | 59 | procedure Move (Target : in out Holder; Source : in out Holder); 60 | 61 | private 62 | 63 | -- not specified by the language 64 | 65 | end Ada.Containers.Indefinite_Holders; 66 | -------------------------------------------------------------------------------- /interfaces-c-pointers.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | generic 11 | type Index is (<>); 12 | type Element is private; 13 | type Element_Array is array (Index range <>) of aliased Element; 14 | Default_Terminator : Element; 15 | package Interfaces.C.Pointers is 16 | pragma Preelaborate (Pointers); 17 | 18 | type Pointer is access all Element; 19 | 20 | function Value (Ref : in Pointer; 21 | Terminator : in Element := Default_Terminator) 22 | return Element_Array; 23 | 24 | function Value (Ref : in Pointer; 25 | Length : in ptrdiff_t) 26 | return Element_Array; 27 | 28 | Pointer_Error : exception; 29 | 30 | -- C-style Pointer arithmetic 31 | 32 | function "+" (Left : in Pointer; Right : in ptrdiff_t) return Pointer; 33 | function "+" (Left : in ptrdiff_t; Right : in Pointer) return Pointer; 34 | function "-" (Left : in Pointer; Right : in ptrdiff_t) return Pointer; 35 | function "-" (Left : in Pointer; Right : in Pointer) return ptrdiff_t; 36 | 37 | procedure Increment (Ref : in out Pointer); 38 | procedure Decrement (Ref : in out Pointer); 39 | 40 | pragma Convention (Intrinsic, "+"); 41 | pragma Convention (Intrinsic, "-"); 42 | pragma Convention (Intrinsic, Increment); 43 | pragma Convention (Intrinsic, Decrement); 44 | 45 | function Virtual_Length (Ref : in Pointer; 46 | Terminator : in Element := Default_Terminator) 47 | return ptrdiff_t; 48 | 49 | procedure Copy_Terminated_Array 50 | (Source : in Pointer; 51 | Target : in Pointer; 52 | Limit : in ptrdiff_t := ptrdiff_t'Last; 53 | Terminator : in Element := Default_Terminator); 54 | 55 | procedure Copy_Array (Source : in Pointer; 56 | Target : in Pointer; 57 | Length : in ptrdiff_t); 58 | 59 | end Interfaces.C.Pointers; 60 | 61 | 62 | 63 | -------------------------------------------------------------------------------- /ada-execution_time-group_budgets.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with System; 11 | 12 | package Ada.Execution_Time.Group_Budgets is 13 | 14 | type Group_Budget is tagged limited private; 15 | 16 | type Group_Budget_Handler is 17 | access protected procedure (GB : in out Group_Budget); 18 | 19 | type Task_Array is 20 | array (Positive range <>) of Ada.Task_Identification.Task_Id; 21 | 22 | Min_Handler_Ceiling : constant System.Any_Priority 23 | := implementation_defined; 24 | 25 | procedure Add_Task (GB : in out Group_Budget; 26 | T : in Ada.Task_Identification.Task_Id); 27 | 28 | procedure Remove_Task (GB : in out Group_Budget; 29 | T : in Ada.Task_Identification.Task_Id); 30 | 31 | function Is_Member (GB : in Group_Budget; 32 | T : in Ada.Task_Identification.Task_Id) 33 | return Boolean; 34 | 35 | function Is_A_Group_Member (T : in Ada.Task_Identification.Task_Id) 36 | return Boolean; 37 | 38 | function Members (GB : in Group_Budget) return Task_Array; 39 | 40 | procedure Replenish (GB : in out Group_Budget; 41 | To : in Ada.Real_Time.Time_Span); 42 | 43 | procedure Add (GB : in out Group_Budget; 44 | Interval : in Ada.Real_Time.Time_Span); 45 | 46 | function Budget_Has_Expired (GB : in Group_Budget) return Boolean; 47 | 48 | function Budget_Remaining (GB : in Group_Budget) 49 | return Ada.Real_Time.Time_Span; 50 | 51 | procedure Set_Handler (GB : in out Group_Budget; 52 | Handler : in Group_Budget_Handler); 53 | 54 | function Current_Handler (GB : in Group_Budget) return Group_Budget_Handler; 55 | 56 | procedure Cancel_Handler (GB : in out Group_Budget; 57 | Cancelled : out Boolean); 58 | 59 | Group_Budget_Error : exception; 60 | 61 | private 62 | 63 | pragma Import (Ada, Group_Budget); 64 | 65 | end Ada.Execution_Time.Group_Budgets; 66 | -------------------------------------------------------------------------------- /ada-sequential_io.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.IO_Exceptions; 11 | generic 12 | type Element_Type (<>) is private; 13 | package Ada.Sequential_IO is 14 | 15 | type File_Type is limited private; 16 | 17 | type File_Mode is (In_File, Out_File, Append_File); 18 | 19 | -- File management 20 | 21 | procedure Create (File : in out File_Type; 22 | Mode : in File_Mode := Out_File; 23 | Name : in String := ""; 24 | Form : in String := ""); 25 | 26 | procedure Open (File : in out File_Type; 27 | Mode : in File_Mode; 28 | Name : in String; 29 | Form : in String := ""); 30 | 31 | procedure Close (File : in out File_Type); 32 | procedure Delete (File : in out File_Type); 33 | procedure Reset (File : in out File_Type; Mode : in File_Mode); 34 | procedure Reset (File : in out File_Type); 35 | 36 | function Mode (File : in File_Type) return File_Mode; 37 | function Name (File : in File_Type) return String; 38 | function Form (File : in File_Type) return String; 39 | 40 | function Is_Open (File : in File_Type) return Boolean; 41 | 42 | -- Input and output operations 43 | 44 | procedure Read (File : in File_Type; Item : out Element_Type); 45 | procedure Write (File : in File_Type; Item : in Element_Type); 46 | 47 | function End_Of_File (File : in File_Type) return Boolean; 48 | 49 | -- Exceptions 50 | 51 | Status_Error : exception renames IO_Exceptions.Status_Error; 52 | Mode_Error : exception renames IO_Exceptions.Mode_Error; 53 | Name_Error : exception renames IO_Exceptions.Name_Error; 54 | Use_Error : exception renames IO_Exceptions.Use_Error; 55 | Device_Error : exception renames IO_Exceptions.Device_Error; 56 | End_Error : exception renames IO_Exceptions.End_Error; 57 | Data_Error : exception renames IO_Exceptions.Data_Error; 58 | 59 | private 60 | 61 | type File_Type is limited null record; 62 | 63 | end Ada.Sequential_IO; 64 | 65 | 66 | 67 | -------------------------------------------------------------------------------- /ada-strings-wide_maps-wide_constants.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.Strings.Wide_Maps.Wide_Constants is 11 | pragma Preelaborate (Wide_Constants); 12 | 13 | Control_Set : constant Wide_Character_Set; 14 | Graphic_Set : constant Wide_Character_Set; 15 | Letter_Set : constant Wide_Character_Set; 16 | Lower_Set : constant Wide_Character_Set; 17 | Upper_Set : constant Wide_Character_Set; 18 | Basic_Set : constant Wide_Character_Set; 19 | Decimal_Digit_Set : constant Wide_Character_Set; 20 | Hexadecimal_Digit_Set : constant Wide_Character_Set; 21 | Alphanumeric_Set : constant Wide_Character_Set; 22 | Special_Set : constant Wide_Character_Set; 23 | ISO_646_Set : constant Wide_Character_Set; 24 | Character_Set : constant Wide_Character_Set; 25 | -- Contains each Wide_Character value WC such that 26 | -- Characters.Conversions.Is_Character(WC) is True 27 | 28 | Lower_Case_Map : constant Wide_Character_Mapping; 29 | -- Wide_Maps to lower case for letters, else identity 30 | Upper_Case_Map : constant Wide_Character_Mapping; 31 | -- Wide_Maps to upper case for letters, else identity 32 | Basic_Map : constant Wide_Character_Mapping; 33 | -- Wide_Maps to basic letter for letters, else identity 34 | 35 | private 36 | 37 | pragma Import (Ada, Control_Set); 38 | pragma Import (Ada, Graphic_Set); 39 | pragma Import (Ada, Letter_Set); 40 | pragma Import (Ada, Lower_Set); 41 | pragma Import (Ada, Upper_Set); 42 | pragma Import (Ada, Basic_Set); 43 | pragma Import (Ada, Decimal_Digit_Set); 44 | pragma Import (Ada, Hexadecimal_Digit_Set); 45 | pragma Import (Ada, Alphanumeric_Set); 46 | pragma Import (Ada, Special_Set); 47 | pragma Import (Ada, ISO_646_Set); 48 | 49 | pragma Import (Ada, Lower_Case_Map); 50 | pragma Import (Ada, Upper_Case_Map); 51 | pragma Import (Ada, Basic_Map); 52 | pragma Import (Ada, Character_Set); 53 | 54 | end Ada.Strings.Wide_Maps.Wide_Constants; 55 | 56 | 57 | 58 | -------------------------------------------------------------------------------- /ada-execution_time.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Real_Time; 11 | with Ada.Task_Identification; 12 | 13 | package Ada.Execution_Time is 14 | 15 | type CPU_Time is private; 16 | 17 | CPU_Time_First : constant CPU_Time; 18 | CPU_Time_Last : constant CPU_Time; 19 | CPU_Time_Unit : constant := implementation_defined; 20 | 21 | CPU_Tick : constant Ada.Real_Time.Time_Span; 22 | 23 | function Clock (T : in Ada.Task_Identification.Task_Id 24 | := Ada.Task_Identification.Current_Task) 25 | return CPU_Time; 26 | 27 | function "+" (Left : in CPU_Time; 28 | Right : in Ada.Real_Time.Time_Span) 29 | return CPU_Time; 30 | 31 | function "+" (Left : in Ada.Real_Time.Time_Span; 32 | Right : in CPU_Time) 33 | return CPU_Time; 34 | 35 | function "-" (Left : in CPU_Time; 36 | Right : in Ada.Real_Time.Time_Span) 37 | return CPU_Time; 38 | 39 | function "-" (Left : in CPU_Time; 40 | Right : in CPU_Time) 41 | return Ada.Real_Time.Time_Span; 42 | 43 | function "<" (Left : in CPU_Time; 44 | Right : in CPU_Time) 45 | return Boolean; 46 | 47 | function "<=" (Left : in CPU_Time; 48 | Right : in CPU_Time) 49 | return Boolean; 50 | 51 | function ">" (Left : in CPU_Time; 52 | Right : in CPU_Time) 53 | return Boolean; 54 | 55 | function ">=" (Left : in CPU_Time; 56 | Right : in CPU_Time) 57 | return Boolean; 58 | 59 | procedure Split (T : in CPU_Time; 60 | SC : out Ada.Real_Time.Seconds_Count; 61 | TS : out Ada.Real_Time.Time_Span); 62 | 63 | function Time_Of (SC : in Ada.Real_Time.Seconds_Count; 64 | TS : in Ada.Real_Time.Time_Span 65 | := Ada.Real_Time.Time_Span_Zero) 66 | return CPU_Time; 67 | 68 | private 69 | 70 | pragma Import (Ada, CPU_Time); 71 | pragma Import (Ada, CPU_Time_First); 72 | pragma Import (Ada, CPU_Time_Last); 73 | pragma Import (Ada, CPU_Tick); 74 | 75 | end Ada.Execution_Time; 76 | -------------------------------------------------------------------------------- /ada-characters-conversions.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.Characters.Conversions is 11 | 12 | pragma Pure (Conversions); 13 | 14 | function Is_Character (Item : in Wide_Character) return Boolean; 15 | 16 | function Is_String (Item : in Wide_String) return Boolean; 17 | 18 | function Is_Character (Item : in Wide_Wide_Character) return Boolean; 19 | 20 | function Is_String (Item : in Wide_Wide_String) return Boolean; 21 | 22 | function Is_Wide_Character (Item : in Wide_Wide_Character) return Boolean; 23 | 24 | function Is_Wide_String (Item : in Wide_Wide_String) return Boolean; 25 | 26 | function To_Wide_Character (Item : in Character) return Wide_Character; 27 | 28 | function To_Wide_String (Item : in String) return Wide_String; 29 | 30 | function To_Wide_Wide_Character (Item : in Character) 31 | return Wide_Wide_Character; 32 | 33 | function To_Wide_Wide_String (Item : in String) return Wide_Wide_String; 34 | 35 | function To_Wide_Wide_Character (Item : in Wide_Character) 36 | return Wide_Wide_Character; 37 | 38 | function To_Wide_Wide_String (Item : in Wide_String) 39 | return Wide_Wide_String; 40 | 41 | function To_Character (Item : in Wide_Character; 42 | Substitute : in Character := ' ') 43 | return Character; 44 | 45 | function To_String (Item : in Wide_String; 46 | Substitute : in Character := ' ') 47 | return String; 48 | 49 | function To_Character (Item : in Wide_Wide_Character; 50 | Substitute : in Character := ' ') 51 | return Character; 52 | 53 | function To_String (Item : in Wide_Wide_String; 54 | Substitute : in Character := ' ') 55 | return String; 56 | 57 | function To_Wide_Character (Item : in Wide_Wide_Character; 58 | Substitute : in Wide_Character := ' ') 59 | return Wide_Character; 60 | 61 | function To_Wide_String (Item : in Wide_Wide_String; 62 | Substitute : in Wide_Character := ' ') 63 | return Wide_String; 64 | 65 | end Ada.Characters.Conversions; 66 | -------------------------------------------------------------------------------- /ada-strings-wide_wide_maps-wide_wide_constants.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.Strings.Wide_Wide_Maps.Wide_Wide_Constants is 11 | pragma Preelaborate (Wide_Wide_Constants); 12 | 13 | Control_Set : constant Wide_Wide_Character_Set; 14 | Graphic_Set : constant Wide_Wide_Character_Set; 15 | Letter_Set : constant Wide_Wide_Character_Set; 16 | Lower_Set : constant Wide_Wide_Character_Set; 17 | Upper_Set : constant Wide_Wide_Character_Set; 18 | Basic_Set : constant Wide_Wide_Character_Set; 19 | Decimal_Digit_Set : constant Wide_Wide_Character_Set; 20 | Hexadecimal_Digit_Set : constant Wide_Wide_Character_Set; 21 | Alphanumeric_Set : constant Wide_Wide_Character_Set; 22 | Special_Set : constant Wide_Wide_Character_Set; 23 | ISO_646_Set : constant Wide_Wide_Character_Set; 24 | 25 | Character_Set : constant Wide_Wide_Character_Set; 26 | -- Contains each Wide_Wide_Character value WWC such that 27 | -- Characters.Conversions.Is_Character(WWC) is True 28 | 29 | Wide_Character_Set : constant Wide_Wide_Character_Set; 30 | -- Contains each Wide_Wide_Character value WWC such that 31 | -- Characters.Conversions.Is_Wide_Character(WWC) is True 32 | 33 | Lower_Case_Map : constant Wide_Wide_Character_Mapping; 34 | --Wide_Wide_Maps to lower case for letters, else identity 35 | Upper_Case_Map : constant Wide_Wide_Character_Mapping; 36 | --Wide_Wide_Maps to upper case for letters, else identity 37 | Basic_Map : constant Wide_Wide_Character_Mapping; 38 | --Wide_Wide_Maps to basic letter for letters, else identity 39 | 40 | private 41 | 42 | pragma Import (Ada, Control_Set); 43 | pragma Import (Ada, Graphic_Set); 44 | pragma Import (Ada, Letter_Set); 45 | pragma Import (Ada, Lower_Set); 46 | pragma Import (Ada, Upper_Set); 47 | pragma Import (Ada, Basic_Set); 48 | pragma Import (Ada, Decimal_Digit_Set); 49 | pragma Import (Ada, Hexadecimal_Digit_Set); 50 | pragma Import (Ada, Alphanumeric_Set); 51 | pragma Import (Ada, Special_Set); 52 | pragma Import (Ada, ISO_646_Set); 53 | pragma Import (Ada, Character_Set); 54 | pragma Import (Ada, Wide_Character_Set); 55 | 56 | pragma Import (Ada, Lower_Case_Map); 57 | pragma Import (Ada, Upper_Case_Map); 58 | pragma Import (Ada, Basic_Map); 59 | 60 | end Ada.Strings.Wide_Wide_Maps.Wide_Wide_Constants; 61 | 62 | 63 | 64 | -------------------------------------------------------------------------------- /system-storage_pools-subpools.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2004-2016 AXE Consultants 3 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 4 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 5 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 6 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 7 | --------------------------------------------------------------------------- 8 | 9 | 10 | package System.Storage_Pools.Subpools is 11 | pragma Preelaborate (Subpools); 12 | 13 | type Root_Storage_Pool_With_Subpools is 14 | abstract new Root_Storage_Pool with private; 15 | 16 | type Root_Subpool is abstract tagged limited private; 17 | 18 | type Subpool_Handle is access all Root_Subpool'Class; 19 | for Subpool_Handle'Storage_Size use 0; 20 | 21 | function Create_Subpool (Pool : in out Root_Storage_Pool_With_Subpools) 22 | return not null Subpool_Handle is abstract; 23 | 24 | -- The following operations are intended for pool implementers: 25 | 26 | function Pool_of_Subpool (Subpool : not null Subpool_Handle) 27 | return access Root_Storage_Pool_With_Subpools'Class; 28 | 29 | procedure Set_Pool_of_Subpool ( 30 | Subpool : in not null Subpool_Handle; 31 | To : in out Root_Storage_Pool_With_Subpools'Class); 32 | 33 | procedure Allocate_From_Subpool ( 34 | Pool : in out Root_Storage_Pool_With_Subpools; 35 | Storage_Address : out Address; 36 | Size_In_Storage_Elements : in Storage_Elements.Storage_Count; 37 | Alignment : in Storage_Elements.Storage_Count; 38 | Subpool : in not null Subpool_Handle) is abstract 39 | with Pre'Class => Pool_of_Subpool(Subpool) = Pool'Access; 40 | 41 | procedure Deallocate_Subpool ( 42 | Pool : in out Root_Storage_Pool_With_Subpools; 43 | Subpool : in out Subpool_Handle) is abstract 44 | with Pre'Class => Pool_of_Subpool(Subpool) = Pool'Access; 45 | 46 | function Default_Subpool_for_Pool ( 47 | Pool : in out Root_Storage_Pool_With_Subpools) 48 | return not null Subpool_Handle; 49 | 50 | overriding 51 | procedure Allocate ( 52 | Pool : in out Root_Storage_Pool_With_Subpools; 53 | Storage_Address : out Address; 54 | Size_In_Storage_Elements : in Storage_Elements.Storage_Count; 55 | Alignment : in Storage_Elements.Storage_Count); 56 | 57 | overriding 58 | procedure Deallocate ( 59 | Pool : in out Root_Storage_Pool_With_Subpools; 60 | Storage_Address : in Address; 61 | Size_In_Storage_Elements : in Storage_Elements.Storage_Count; 62 | Alignment : in Storage_Elements.Storage_Count) is null; 63 | 64 | overriding 65 | function Storage_Size (Pool : Root_Storage_Pool_With_Subpools) 66 | return Storage_Elements.Storage_Count 67 | is (Storage_Elements.Storage_Count'Last); 68 | 69 | private 70 | -- not specified by the language 71 | end System.Storage_Pools.Subpools; 72 | -------------------------------------------------------------------------------- /ada-direct_io.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.IO_Exceptions; 11 | generic 12 | type Element_Type is private; 13 | package Ada.Direct_IO is 14 | 15 | type File_Type is limited private; 16 | 17 | type File_Mode is (In_File, Inout_File, Out_File); 18 | type Count is range 0 .. implementation_defined; 19 | subtype Positive_Count is Count range 1 .. Count'Last; 20 | 21 | -- File management 22 | 23 | procedure Create (File : in out File_Type; 24 | Mode : in File_Mode := Inout_File; 25 | Name : in String := ""; 26 | Form : in String := ""); 27 | 28 | procedure Open (File : in out File_Type; 29 | Mode : in File_Mode; 30 | Name : in String; 31 | Form : in String := ""); 32 | 33 | procedure Close (File : in out File_Type); 34 | procedure Delete (File : in out File_Type); 35 | procedure Reset (File : in out File_Type; Mode : in File_Mode); 36 | procedure Reset (File : in out File_Type); 37 | 38 | function Mode (File : in File_Type) return File_Mode; 39 | function Name (File : in File_Type) return String; 40 | function Form (File : in File_Type) return String; 41 | 42 | function Is_Open (File : in File_Type) return Boolean; 43 | 44 | -- Input and output operations 45 | 46 | procedure Read (File : in File_Type; Item : out Element_Type; 47 | From : in Positive_Count); 48 | procedure Read (File : in File_Type; Item : out Element_Type); 49 | 50 | procedure Write (File : in File_Type; Item : in Element_Type; 51 | To : in Positive_Count); 52 | procedure Write (File : in File_Type; Item : in Element_Type); 53 | 54 | procedure Set_Index (File : in File_Type; To : in Positive_Count); 55 | 56 | function Index (File : in File_Type) return Positive_Count; 57 | function Size (File : in File_Type) return Count; 58 | 59 | function End_Of_File (File : in File_Type) return Boolean; 60 | 61 | -- Exceptions 62 | 63 | Status_Error : exception renames IO_Exceptions.Status_Error; 64 | Mode_Error : exception renames IO_Exceptions.Mode_Error; 65 | Name_Error : exception renames IO_Exceptions.Name_Error; 66 | Use_Error : exception renames IO_Exceptions.Use_Error; 67 | Device_Error : exception renames IO_Exceptions.Device_Error; 68 | End_Error : exception renames IO_Exceptions.End_Error; 69 | Data_Error : exception renames IO_Exceptions.Data_Error; 70 | 71 | private 72 | 73 | type File_Type is limited null record; 74 | 75 | end Ada.Direct_IO; 76 | 77 | 78 | 79 | -------------------------------------------------------------------------------- /ada-numerics-generic_complex_elementary_functions.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Numerics.Generic_Complex_Types; 11 | 12 | generic 13 | with package Complex_Types is new Ada.Numerics.Generic_Complex_Types (<>); 14 | 15 | package Ada.Numerics.Generic_Complex_Elementary_Functions is 16 | 17 | pragma Pure (Generic_Complex_Elementary_Functions); 18 | 19 | function Sqrt (X : in Complex_Types.Complex) return Complex_Types.Complex; 20 | 21 | function Log (X : in Complex_Types.Complex) return Complex_Types.Complex; 22 | 23 | function Exp (X : in Complex_Types.Complex) return Complex_Types.Complex; 24 | 25 | function Exp (X : in Complex_Types.Imaginary) return Complex_Types.Complex; 26 | 27 | function "**" (Left : in Complex_Types.Complex; 28 | Right : in Complex_Types.Complex) 29 | return Complex_Types.Complex; 30 | 31 | function "**" (Left : in Complex_Types.Complex; 32 | Right : in Complex_Types.Real'Base) 33 | return Complex_Types.Complex; 34 | 35 | function "**" (Left : in Complex_Types.Real'Base; 36 | Right : in Complex_Types.Complex) 37 | return Complex_Types.Complex; 38 | 39 | function Sin (X : in Complex_Types.Complex) return Complex_Types.Complex; 40 | 41 | function Cos (X : in Complex_Types.Complex) return Complex_Types.Complex; 42 | 43 | function Tan (X : in Complex_Types.Complex) return Complex_Types.Complex; 44 | 45 | function Cot (X : in Complex_Types.Complex) return Complex_Types.Complex; 46 | 47 | function Arcsin (X : in Complex_Types.Complex) 48 | return Complex_Types.Complex; 49 | 50 | function Arccos (X : in Complex_Types.Complex) 51 | return Complex_Types.Complex; 52 | 53 | function Arctan (X : in Complex_Types.Complex) 54 | return Complex_Types.Complex; 55 | 56 | function Arccot (X : in Complex_Types.Complex) 57 | return Complex_Types.Complex; 58 | 59 | function Sinh (X : in Complex_Types.Complex) return Complex_Types.Complex; 60 | 61 | function Cosh (X : in Complex_Types.Complex) return Complex_Types.Complex; 62 | 63 | function Tanh (X : in Complex_Types.Complex) return Complex_Types.Complex; 64 | 65 | function Coth (X : in Complex_Types.Complex) return Complex_Types.Complex; 66 | 67 | function Arcsinh (X : in Complex_Types.Complex) 68 | return Complex_Types.Complex; 69 | 70 | function Arccosh (X : in Complex_Types.Complex) 71 | return Complex_Types.Complex; 72 | 73 | function Arctanh (X : in Complex_Types.Complex) 74 | return Complex_Types.Complex; 75 | 76 | function Arccoth (X : in Complex_Types.Complex) 77 | return Complex_Types.Complex; 78 | 79 | end Ada.Numerics.Generic_Complex_Elementary_Functions; 80 | -------------------------------------------------------------------------------- /ada-exceptions.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Streams; 11 | 12 | package Ada.Exceptions is 13 | 14 | pragma Preelaborate (Exceptions); 15 | 16 | type Exception_Id is private; 17 | pragma Preelaborable_Initialization (Exception_Id); 18 | 19 | Null_Id : constant Exception_Id; 20 | 21 | function Exception_Name (Id : in Exception_Id) return String; 22 | 23 | function Wide_Exception_Name (Id : in Exception_Id) return Wide_String; 24 | 25 | function Wide_Wide_Exception_Name (Id : in Exception_Id) 26 | return Wide_Wide_String; 27 | 28 | type Exception_Occurrence is limited private; 29 | pragma Preelaborable_Initialization (Exception_Occurrence); 30 | 31 | type Exception_Occurrence_Access is access all Exception_Occurrence; 32 | 33 | Null_Occurrence : constant Exception_Occurrence; 34 | 35 | procedure Raise_Exception (E : in Exception_Id; 36 | Message : in String := ""); 37 | pragma No_Return (Raise_Exception); 38 | 39 | function Exception_Message (X : in Exception_Occurrence) return String; 40 | 41 | procedure Reraise_Occurrence (X : in Exception_Occurrence); 42 | 43 | function Exception_Identity (X : in Exception_Occurrence) 44 | return Exception_Id; 45 | 46 | function Exception_Name (X : in Exception_Occurrence) return String; 47 | -- Same as Exception_Name(Exception_Identity(X)). 48 | 49 | function Wide_Exception_Name (X : in Exception_Occurrence) 50 | return Wide_String; 51 | -- Same as Wide_Exception_Name(Exception_Identity(X)). 52 | 53 | function Wide_Wide_Exception_Name (X : in Exception_Occurrence) 54 | return Wide_Wide_String; 55 | -- Same as Wide_Wide_Exception_Name(Exception_Identity(X)). 56 | 57 | function Exception_Information (X : in Exception_Occurrence) return String; 58 | 59 | procedure Save_Occurrence (Target : out Exception_Occurrence; 60 | Source : in Exception_Occurrence); 61 | 62 | function Save_Occurrence (Source : in Exception_Occurrence) 63 | return Exception_Occurrence_Access; 64 | 65 | procedure Read_Exception_Occurrence 66 | (Stream : not null access Ada.Streams.Root_Stream_Type'Class; 67 | Item : out Exception_Occurrence); 68 | 69 | procedure Write_Exception_Occurrence 70 | (Stream : not null access Ada.Streams.Root_Stream_Type'Class; 71 | Item : in Exception_Occurrence); 72 | 73 | for Exception_Occurrence'Read use Read_Exception_Occurrence; 74 | for Exception_Occurrence'Write use Write_Exception_Occurrence; 75 | 76 | private 77 | 78 | pragma Import (Ada, Exception_Id); 79 | pragma Import (Ada, Exception_Occurrence); 80 | pragma Import (Ada, Null_Id); 81 | pragma Import (Ada, Null_Occurrence); 82 | 83 | end Ada.Exceptions; 84 | -------------------------------------------------------------------------------- /interfaces.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Interfaces is 11 | pragma Pure(Interfaces); 12 | 13 | type Integer_8 is range -2**(8-1) .. 2**(8-1) - 1; 14 | type Unsigned_8 is mod 2**8; 15 | 16 | function Shift_Left (Value : Unsigned_8; Amount : Natural) 17 | return Unsigned_8; 18 | function Shift_Right (Value : Unsigned_8; Amount : Natural) 19 | return Unsigned_8; 20 | function Shift_Right_Arithmetic (Value : Unsigned_8; Amount : Natural) 21 | return Unsigned_8; 22 | function Rotate_Left (Value : Unsigned_8; Amount : Natural) 23 | return Unsigned_8; 24 | function Rotate_Right (Value : Unsigned_8; Amount : Natural) 25 | return Unsigned_8; 26 | 27 | type Integer_16 is range -2**(16-1) .. 2**(16-1) - 1; 28 | type Unsigned_16 is mod 2**16; 29 | 30 | function Shift_Left (Value : Unsigned_16; Amount : Natural) 31 | return Unsigned_16; 32 | function Shift_Right (Value : Unsigned_16; Amount : Natural) 33 | return Unsigned_16; 34 | function Shift_Right_Arithmetic (Value : Unsigned_16; Amount : Natural) 35 | return Unsigned_16; 36 | function Rotate_Left (Value : Unsigned_16; Amount : Natural) 37 | return Unsigned_16; 38 | function Rotate_Right (Value : Unsigned_16; Amount : Natural) 39 | return Unsigned_16; 40 | 41 | type Integer_32 is range -2**(32-1) .. 2**(32-1) - 1; 42 | type Unsigned_32 is mod 2**32; 43 | 44 | function Shift_Left (Value : Unsigned_32; Amount : Natural) 45 | return Unsigned_32; 46 | function Shift_Right (Value : Unsigned_32; Amount : Natural) 47 | return Unsigned_32; 48 | function Shift_Right_Arithmetic (Value : Unsigned_32; Amount : Natural) 49 | return Unsigned_32; 50 | function Rotate_Left (Value : Unsigned_32; Amount : Natural) 51 | return Unsigned_32; 52 | function Rotate_Right (Value : Unsigned_32; Amount : Natural) 53 | return Unsigned_32; 54 | 55 | type Integer_64 is range -2**(64-1) .. 2**(64-1) - 1; 56 | type Unsigned_64 is mod 2**64; 57 | 58 | function Shift_Left (Value : Unsigned_64; Amount : Natural) 59 | return Unsigned_64; 60 | function Shift_Right (Value : Unsigned_64; Amount : Natural) 61 | return Unsigned_64; 62 | function Shift_Right_Arithmetic (Value : Unsigned_64; Amount : Natural) 63 | return Unsigned_64; 64 | function Rotate_Left (Value : Unsigned_64; Amount : Natural) 65 | return Unsigned_64; 66 | function Rotate_Right (Value : Unsigned_64; Amount : Natural) 67 | return Unsigned_64; 68 | 69 | end Interfaces; 70 | 71 | 72 | 73 | -------------------------------------------------------------------------------- /system.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package System is 11 | pragma Pure (System); 12 | 13 | type Name is (implementation_defined); 14 | -- implementation_defined-enumeration-type; 15 | System_Name : constant Name := implementation_defined; 16 | 17 | -- System-Dependent Named Numbers: 18 | 19 | Min_Int : constant := root_integer'First; 20 | Max_Int : constant := root_integer'Last; 21 | 22 | Max_Binary_Modulus : constant := implementation_defined; 23 | Max_Nonbinary_Modulus : constant := implementation_defined; 24 | 25 | Max_Base_Digits : constant := root_real'Digits; 26 | Max_Digits : constant := implementation_defined; 27 | 28 | Max_Mantissa : constant := implementation_defined; 29 | Fine_Delta : constant := implementation_defined; 30 | 31 | Tick : constant := implementation_defined; 32 | 33 | -- Storage-related Declarations: 34 | 35 | type Address is private; -- implementation_defined; 36 | Null_Address : constant Address; 37 | 38 | Storage_Unit : constant := implementation_defined; 39 | Word_Size : constant := implementation_defined * Storage_Unit; 40 | Memory_Size : constant := implementation_defined; 41 | 42 | -- Address Comparison: 43 | function "<" (Left, Right : Address) return Boolean; 44 | function "<=" (Left, Right : Address) return Boolean; 45 | function ">" (Left, Right : Address) return Boolean; 46 | function ">=" (Left, Right : Address) return Boolean; 47 | function "=" (Left, Right : Address) return Boolean; 48 | -- function "/=" (Left, Right : Address) return Boolean; 49 | -- "/=" is implicitly defined 50 | pragma Convention (Intrinsic, "<"); 51 | pragma Convention (Intrinsic, "<="); 52 | pragma Convention (Intrinsic, ">"); 53 | pragma Convention (Intrinsic, ">="); 54 | pragma Convention (Intrinsic, "="); 55 | -- and so on for all language-defined subprograms in this package 56 | 57 | -- Other System-Dependent Declarations: 58 | type Bit_Order is (High_Order_First, Low_Order_First); 59 | Default_Bit_Order : constant Bit_Order := implementation_defined; 60 | 61 | -- Priority-related declarations (see D.1): 62 | subtype Any_Priority is 63 | Integer range implementation_defined .. implementation_defined; 64 | subtype Priority is 65 | Any_Priority range Any_Priority'First .. implementation_defined; 66 | subtype Interrupt_Priority is Any_Priority 67 | range Priority'Last + 1 .. Any_Priority'Last; 68 | 69 | Default_Priority : constant Priority := 70 | (Priority'First + Priority'Last) / 2; 71 | 72 | private 73 | 74 | pragma Import (Ada, Address); 75 | pragma Import (Ada, Null_Address); 76 | pragma Import (Intrinsic, "<"); 77 | pragma Import (Intrinsic, "<="); 78 | pragma Import (Intrinsic, ">"); 79 | pragma Import (Intrinsic, ">="); 80 | pragma Import (Intrinsic, "="); 81 | 82 | end System; 83 | 84 | 85 | 86 | -------------------------------------------------------------------------------- /ada-numerics-generic_elementary_functions.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | generic 11 | type Float_Type is digits <>; 12 | 13 | package Ada.Numerics.Generic_Elementary_Functions is 14 | pragma Pure (Generic_Elementary_Functions); 15 | 16 | function Sqrt 17 | (X : Float_Type'Base) return Float_Type'Base; 18 | function Log 19 | (X : Float_Type'Base) return Float_Type'Base; 20 | function Log 21 | (X, Base : Float_Type'Base) return Float_Type'Base; 22 | function Exp 23 | (X : Float_Type'Base) return Float_Type'Base; 24 | function "**" (Left, Right : Float_Type'Base) return Float_Type'Base; 25 | 26 | function Sin 27 | (X : Float_Type'Base) return Float_Type'Base; 28 | function Sin 29 | (X, Cycle : Float_Type'Base) return Float_Type'Base; 30 | function Cos 31 | (X : Float_Type'Base) return Float_Type'Base; 32 | function Cos 33 | (X, Cycle : Float_Type'Base) return Float_Type'Base; 34 | function Tan 35 | (X : Float_Type'Base) return Float_Type'Base; 36 | function Tan 37 | (X, Cycle : Float_Type'Base) return Float_Type'Base; 38 | function Cot 39 | (X : Float_Type'Base) return Float_Type'Base; 40 | function Cot 41 | (X, Cycle : Float_Type'Base) return Float_Type'Base; 42 | 43 | function Arcsin 44 | (X : Float_Type'Base) return Float_Type'Base; 45 | function Arcsin 46 | (X, Cycle : Float_Type'Base) return Float_Type'Base; 47 | function Arccos 48 | (X : Float_Type'Base) return Float_Type'Base; 49 | function Arccos 50 | (X, Cycle : Float_Type'Base) return Float_Type'Base; 51 | function Arctan (Y : Float_Type'Base; 52 | X : Float_Type'Base := 1.0) 53 | return Float_Type'Base; 54 | function Arctan (Y : Float_Type'Base; 55 | X : Float_Type'Base := 1.0; 56 | Cycle : Float_Type'Base) return Float_Type'Base; 57 | function Arccot (X : Float_Type'Base; 58 | Y : Float_Type'Base := 1.0) 59 | return Float_Type'Base; 60 | function Arccot (X : Float_Type'Base; 61 | Y : Float_Type'Base := 1.0; 62 | Cycle : Float_Type'Base) return Float_Type'Base; 63 | 64 | function Sinh 65 | (X : Float_Type'Base) return Float_Type'Base; 66 | function Cosh 67 | (X : Float_Type'Base) return Float_Type'Base; 68 | function Tanh 69 | (X : Float_Type'Base) return Float_Type'Base; 70 | function Coth 71 | (X : Float_Type'Base) return Float_Type'Base; 72 | function Arcsinh 73 | (X : Float_Type'Base) return Float_Type'Base; 74 | function Arccosh 75 | (X : Float_Type'Base) return Float_Type'Base; 76 | function Arctanh 77 | (X : Float_Type'Base) return Float_Type'Base; 78 | function Arccoth 79 | (X : Float_Type'Base) return Float_Type'Base; 80 | 81 | end Ada.Numerics.Generic_Elementary_Functions; 82 | 83 | 84 | 85 | -------------------------------------------------------------------------------- /ada-strings-maps.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.Strings.Maps is 11 | pragma Pure (Maps); 12 | 13 | -- Representation for a set of character values: 14 | type Character_Set is private; 15 | pragma Preelaborable_Initialization (Character_Set); 16 | 17 | Null_Set : constant Character_Set; 18 | 19 | type Character_Range is 20 | record 21 | Low : Character; 22 | High : Character; 23 | end record; 24 | -- Represents Character range Low..High 25 | 26 | type Character_Ranges is 27 | array (Positive range <>) of Character_Range; 28 | 29 | function To_Set 30 | (Ranges : in Character_Ranges) return Character_Set; 31 | 32 | function To_Set (Span : in Character_Range) return Character_Set; 33 | 34 | function To_Ranges 35 | (Set : in Character_Set) return Character_Ranges; 36 | 37 | function "=" (Left, Right : in Character_Set) return Boolean; 38 | 39 | function "not" (Right : in Character_Set) return Character_Set; 40 | function "and" (Left, Right : in Character_Set) return Character_Set; 41 | function "or" (Left, Right : in Character_Set) return Character_Set; 42 | function "xor" (Left, Right : in Character_Set) return Character_Set; 43 | function "-" (Left, Right : in Character_Set) return Character_Set; 44 | 45 | function Is_In (Element : in Character; 46 | Set : in Character_Set) 47 | return Boolean; 48 | 49 | function Is_Subset (Elements : in Character_Set; 50 | Set : in Character_Set) 51 | return Boolean; 52 | 53 | function "<=" (Left : in Character_Set; 54 | Right : in Character_Set) 55 | return Boolean renames Is_Subset; 56 | 57 | -- Alternative representation for a set of character values: 58 | subtype Character_Sequence is String; 59 | 60 | function To_Set 61 | (Sequence : in Character_Sequence)return Character_Set; 62 | 63 | function To_Set (Singleton : in Character) return Character_Set; 64 | 65 | function To_Sequence 66 | (Set : in Character_Set) return Character_Sequence; 67 | 68 | -- Representation for a character to character mapping: 69 | type Character_Mapping is private; 70 | pragma Preelaborable_Initialization (Character_Mapping); 71 | 72 | function Value (Map : in Character_Mapping; 73 | Element : in Character) 74 | return Character; 75 | 76 | Identity : constant Character_Mapping; 77 | 78 | function To_Mapping (From, To : in Character_Sequence) 79 | return Character_Mapping; 80 | 81 | function To_Domain (Map : in Character_Mapping) 82 | return Character_Sequence; 83 | function To_Range (Map : in Character_Mapping) 84 | return Character_Sequence; 85 | 86 | type Character_Mapping_Function is 87 | access function (From : in Character) return Character; 88 | 89 | private 90 | 91 | pragma Import (Ada, Character_Set); 92 | pragma Import (Ada, Null_Set); 93 | pragma Import (Ada, Character_Mapping); 94 | pragma Import (Ada, Identity); 95 | 96 | end Ada.Strings.Maps; 97 | 98 | 99 | 100 | -------------------------------------------------------------------------------- /ada-streams-stream_io.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.IO_Exceptions; 11 | package Ada.Streams.Stream_IO is 12 | pragma Preelaborate(Stream_IO); 13 | 14 | type Stream_Access is access all Root_Stream_Type'Class; 15 | 16 | type File_Type is limited private; 17 | 18 | type File_Mode is (In_File, Out_File, Append_File); 19 | 20 | type Count is range 0 .. implementation_defined; 21 | subtype Positive_Count is Count range 1 .. Count'Last; 22 | -- Index into file, in stream elements. 23 | 24 | procedure Create (File : in out File_Type; 25 | Mode : in File_Mode := Out_File; 26 | Name : in String := ""; 27 | Form : in String := ""); 28 | 29 | procedure Open (File : in out File_Type; 30 | Mode : in File_Mode; 31 | Name : in String; 32 | Form : in String := ""); 33 | 34 | procedure Close (File : in out File_Type); 35 | procedure Delete (File : in out File_Type); 36 | procedure Reset (File : in out File_Type; Mode : in File_Mode); 37 | procedure Reset (File : in out File_Type); 38 | 39 | function Mode (File : in File_Type) return File_Mode; 40 | function Name (File : in File_Type) return String; 41 | function Form (File : in File_Type) return String; 42 | 43 | function Is_Open (File : in File_Type) return Boolean; 44 | function End_Of_File (File : in File_Type) return Boolean; 45 | 46 | function Stream (File : in File_Type) return Stream_Access; 47 | -- Return stream access for use with T'Input and T'Output 48 | 49 | -- Read array of stream elements from file 50 | procedure Read (File : in File_Type; 51 | Item : out Stream_Element_Array; 52 | Last : out Stream_Element_Offset; 53 | From : in Positive_Count); 54 | 55 | procedure Read (File : in File_Type; 56 | Item : out Stream_Element_Array; 57 | Last : out Stream_Element_Offset); 58 | 59 | -- Write array of stream elements into file 60 | procedure Write (File : in File_Type; 61 | Item : in Stream_Element_Array; 62 | To : in Positive_Count); 63 | 64 | procedure Write (File : in File_Type; 65 | Item : in Stream_Element_Array); 66 | 67 | -- Operations on position within file 68 | 69 | procedure Set_Index(File : in File_Type; To : in Positive_Count); 70 | 71 | function Index(File : in File_Type) return Positive_Count; 72 | function Size (File : in File_Type) return Count; 73 | 74 | procedure Set_Mode(File : in out File_Type; Mode : in File_Mode); 75 | 76 | procedure Flush(File : in out File_Type); 77 | 78 | -- exceptions 79 | Status_Error : exception renames IO_Exceptions.Status_Error; 80 | Mode_Error : exception renames IO_Exceptions.Mode_Error; 81 | Name_Error : exception renames IO_Exceptions.Name_Error; 82 | Use_Error : exception renames IO_Exceptions.Use_Error; 83 | Device_Error : exception renames IO_Exceptions.Device_Error; 84 | End_Error : exception renames IO_Exceptions.End_Error; 85 | Data_Error : exception renames IO_Exceptions.Data_Error; 86 | 87 | private 88 | 89 | pragma Import (Ada, File_Type); 90 | 91 | end Ada.Streams.Stream_IO; 92 | 93 | 94 | 95 | -------------------------------------------------------------------------------- /ada-text_io-editing.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.Text_IO.Editing is 11 | 12 | type Picture is private; 13 | 14 | function Valid (Pic_String : in String; 15 | Blank_When_Zero : in Boolean := False) return Boolean; 16 | 17 | function To_Picture (Pic_String : in String; 18 | Blank_When_Zero : in Boolean := False) 19 | return Picture; 20 | 21 | function Pic_String (Pic : in Picture) return String; 22 | function Blank_When_Zero (Pic : in Picture) return Boolean; 23 | 24 | Max_Picture_Length : constant := implementation_defined; 25 | 26 | Picture_Error : exception; 27 | 28 | Default_Currency : constant String := "$"; 29 | Default_Fill : constant Character := '*'; 30 | Default_Separator : constant Character := ','; 31 | Default_Radix_Mark : constant Character := '.'; 32 | 33 | generic 34 | type Num is delta <> digits <>; 35 | 36 | Default_Currency : in String := Text_IO.Editing.Default_Currency; 37 | Default_Fill : in Character := Text_IO.Editing.Default_Fill; 38 | Default_Separator : in Character := Text_IO.Editing.Default_Separator; 39 | Default_Radix_Mark : in Character := Text_IO.Editing.Default_Radix_Mark; 40 | package Decimal_Output is 41 | function Length (Pic : in Picture; 42 | Currency : in String := Default_Currency) 43 | return Natural; 44 | 45 | function Valid (Item : in Num; 46 | Pic : in Picture; 47 | Currency : in String := Default_Currency) 48 | return Boolean; 49 | 50 | function Image (Item : in Num; 51 | Pic : in Picture; 52 | Currency : in String := Default_Currency; 53 | Fill : in Character := Default_Fill; 54 | Separator : in Character := Default_Separator; 55 | Radix_Mark : in Character := Default_Radix_Mark) 56 | return String; 57 | 58 | procedure Put (File : in File_Type; 59 | Item : in Num; 60 | Pic : in Picture; 61 | Currency : in String := Default_Currency; 62 | Fill : in Character := Default_Fill; 63 | Separator : in Character := Default_Separator; 64 | Radix_Mark : in Character := Default_Radix_Mark); 65 | 66 | procedure Put (Item : in Num; 67 | Pic : in Picture; 68 | Currency : in String := Default_Currency; 69 | Fill : in Character := Default_Fill; 70 | Separator : in Character := Default_Separator; 71 | Radix_Mark : in Character := Default_Radix_Mark); 72 | 73 | procedure Put (To : out String; 74 | Item : in Num; 75 | Pic : in Picture; 76 | Currency : in String := Default_Currency; 77 | Fill : in Character := Default_Fill; 78 | Separator : in Character := Default_Separator; 79 | Radix_Mark : in Character := Default_Radix_Mark); 80 | end Decimal_Output; 81 | 82 | private 83 | pragma Import (Ada, Picture); 84 | end Ada.Text_IO.Editing; 85 | -------------------------------------------------------------------------------- /ada-characters-handling.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | with Ada.Characters.Conversions; 11 | 12 | package Ada.Characters.Handling is 13 | pragma Pure (Handling); 14 | 15 | -- Character classification functions 16 | 17 | function Is_Control (Item : in Character) return Boolean; 18 | function Is_Graphic (Item : in Character) return Boolean; 19 | function Is_Letter (Item : in Character) return Boolean; 20 | function Is_Lower (Item : in Character) return Boolean; 21 | function Is_Upper (Item : in Character) return Boolean; 22 | function Is_Basic (Item : in Character) return Boolean; 23 | function Is_Digit (Item : in Character) return Boolean; 24 | function Is_Decimal_Digit (Item : in Character) return Boolean 25 | renames Is_Digit; 26 | function Is_Hexadecimal_Digit (Item : in Character) return Boolean; 27 | function Is_Alphanumeric (Item : in Character) return Boolean; 28 | function Is_Special (Item : in Character) return Boolean; 29 | function Is_Line_Terminator (Item : in Character) return Boolean; 30 | function Is_Mark (Item : in Character) return Boolean; 31 | function Is_Other_Format (Item : in Character) return Boolean; 32 | function Is_Punctuation_Connector (Item : in Character) return Boolean; 33 | function Is_Space (Item : in Character) return Boolean; 34 | 35 | -- Conversion functions for Character and String 36 | 37 | function To_Lower (Item : in Character) return Character; 38 | function To_Upper (Item : in Character) return Character; 39 | function To_Basic (Item : in Character) return Character; 40 | 41 | function To_Lower (Item : in String) return String; 42 | function To_Upper (Item : in String) return String; 43 | function To_Basic (Item : in String) return String; 44 | 45 | -- Classifications of and conversions between Character and ISO 646 46 | 47 | subtype ISO_646 is 48 | Character range Character'Val(0) .. Character'Val(127); 49 | 50 | function Is_ISO_646 (Item : in Character) return Boolean; 51 | function Is_ISO_646 (Item : in String) return Boolean; 52 | 53 | function To_ISO_646 (Item : in Character; 54 | Substitute : in ISO_646 := ' ') 55 | return ISO_646; 56 | 57 | function To_ISO_646 (Item : in String; 58 | Substitute : in ISO_646 := ' ') 59 | return String; 60 | 61 | -- The functions Is_Character, Is_String, To_Character, To_String, 62 | -- To_Wide_Character and To_Wide_String are obsolescent; see J.14. 63 | 64 | function Is_Character (Item : in Wide_Character) return Boolean 65 | renames Conversions.Is_Character; 66 | function Is_String (Item : in Wide_String) return Boolean 67 | renames Conversions.Is_String; 68 | 69 | function To_Character (Item : in Wide_Character; 70 | Substitute : in Character := ' ') 71 | return Character 72 | renames Conversions.To_Character; 73 | 74 | function To_String (Item : in Wide_String; 75 | Substitute : in Character := ' ') 76 | return String 77 | renames Conversions.To_String; 78 | 79 | function To_Wide_Character (Item : in Character) return Wide_Character 80 | renames Conversions.To_Wide_Character; 81 | 82 | function To_Wide_String (Item : in String) return Wide_String 83 | renames Conversions.To_Wide_String; 84 | 85 | end Ada.Characters.Handling; 86 | 87 | 88 | 89 | -------------------------------------------------------------------------------- /ada-wide_wide_text_io-editing.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.Wide_Wide_Text_IO.Editing is 11 | 12 | type Picture is private; 13 | 14 | function Valid (Pic_String : in String; 15 | Blank_When_Zero : in Boolean := False) return Boolean; 16 | 17 | function To_Picture (Pic_String : in String; 18 | Blank_When_Zero : in Boolean := False) 19 | return Picture; 20 | 21 | function Pic_String (Pic : in Picture) return String; 22 | function Blank_When_Zero (Pic : in Picture) return Boolean; 23 | 24 | Max_Picture_Length : constant := implementation_defined; 25 | 26 | Picture_Error : exception; 27 | 28 | Default_Currency : constant Wide_Wide_String := "$"; 29 | Default_Fill : constant Wide_Wide_Character := '*'; 30 | Default_Separator : constant Wide_Wide_Character := ','; 31 | Default_Radix_Mark : constant Wide_Wide_Character := '.'; 32 | 33 | generic 34 | type Num is delta <> digits <>; 35 | 36 | Default_Currency : in String 37 | := Wide_Wide_Text_IO.Editing.Default_Currency; 38 | Default_Fill : in Wide_Wide_Character 39 | := Wide_Wide_Text_IO.Editing.Default_Fill; 40 | Default_Separator : in Wide_Wide_Character 41 | := Wide_Wide_Text_IO.Editing.Default_Separator; 42 | Default_Radix_Mark : in Wide_Wide_Character 43 | := Wide_Wide_Text_IO.Editing.Default_Radix_Mark; 44 | package Decimal_Output is 45 | function Length (Pic : in Picture; 46 | Currency : in Wide_Wide_String := Default_Currency) 47 | return Natural; 48 | 49 | function Valid (Item : in Num; 50 | Pic : in Picture; 51 | Currency : in Wide_Wide_String := Default_Currency) 52 | return Boolean; 53 | 54 | function Image 55 | (Item : in Num; 56 | Pic : in Picture; 57 | Currency : in Wide_Wide_String := Default_Currency; 58 | Fill : in Wide_Wide_Character := Default_Fill; 59 | Separator : in Wide_Wide_Character := Default_Separator; 60 | Radix_Mark : in Wide_Wide_Character := Default_Radix_Mark) 61 | return Wide_Wide_String; 62 | 63 | procedure Put 64 | (File : in File_Type; 65 | Item : in Num; 66 | Pic : in Picture; 67 | Currency : in Wide_Wide_String := Default_Currency; 68 | Fill : in Wide_Wide_Character := Default_Fill; 69 | Separator : in Wide_Wide_Character := Default_Separator; 70 | Radix_Mark : in Wide_Wide_Character := Default_Radix_Mark); 71 | 72 | procedure Put 73 | (Item : in Num; 74 | Pic : in Picture; 75 | Currency : in Wide_Wide_String := Default_Currency; 76 | Fill : in Wide_Wide_Character := Default_Fill; 77 | Separator : in Wide_Wide_Character := Default_Separator; 78 | Radix_Mark : in Wide_Wide_Character := Default_Radix_Mark); 79 | 80 | procedure Put 81 | (To : out Wide_Wide_String; 82 | Item : in Num; 83 | Pic : in Picture; 84 | Currency : in Wide_Wide_String := Default_Currency; 85 | Fill : in Wide_Wide_Character := Default_Fill; 86 | Separator : in Wide_Wide_Character := Default_Separator; 87 | Radix_Mark : in Wide_Wide_Character := Default_Radix_Mark); 88 | end Decimal_Output; 89 | 90 | private 91 | pragma Import (Ada, Picture); 92 | end Ada.Wide_Wide_Text_IO.Editing; 93 | -------------------------------------------------------------------------------- /ada-wide_text_io-editing.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.Wide_Text_IO.Editing is 11 | 12 | type Picture is private; 13 | 14 | function Valid (Pic_String : in String; 15 | Blank_When_Zero : in Boolean := False) return Boolean; 16 | 17 | function To_Picture (Pic_String : in String; 18 | Blank_When_Zero : in Boolean := False) 19 | return Picture; 20 | 21 | function Pic_String (Pic : in Picture) return String; 22 | function Blank_When_Zero (Pic : in Picture) return Boolean; 23 | 24 | Max_Picture_Length : constant := implementation_defined; 25 | 26 | Picture_Error : exception; 27 | 28 | Default_Currency : constant Wide_String := "$"; 29 | Default_Fill : constant Wide_Character := '*'; 30 | Default_Separator : constant Wide_Character := ','; 31 | Default_Radix_Mark : constant Wide_Character := '.'; 32 | 33 | generic 34 | type Num is delta <> digits <>; 35 | 36 | Default_Currency : in String 37 | := Wide_Text_IO.Editing.Default_Currency; 38 | Default_Fill : in Wide_Character 39 | := Wide_Text_IO.Editing.Default_Fill; 40 | Default_Separator : in Wide_Character 41 | := Wide_Text_IO.Editing.Default_Separator; 42 | Default_Radix_Mark : in Wide_Character 43 | := Wide_Text_IO.Editing.Default_Radix_Mark; 44 | package Decimal_Output is 45 | function Length (Pic : in Picture; 46 | Currency : in Wide_String := Default_Currency) 47 | return Natural; 48 | 49 | function Valid (Item : in Num; 50 | Pic : in Picture; 51 | Currency : in Wide_String := Default_Currency) 52 | return Boolean; 53 | 54 | function Image (Item : in Num; 55 | Pic : in Picture; 56 | Currency : in Wide_String := Default_Currency; 57 | Fill : in Wide_Character := Default_Fill; 58 | Separator : in Wide_Character := Default_Separator; 59 | Radix_Mark : in Wide_Character := Default_Radix_Mark) 60 | return Wide_String; 61 | 62 | procedure Put (File : in File_Type; 63 | Item : in Num; 64 | Pic : in Picture; 65 | Currency : in Wide_String := Default_Currency; 66 | Fill : in Wide_Character := Default_Fill; 67 | Separator : in Wide_Character := Default_Separator; 68 | Radix_Mark : in Wide_Character := Default_Radix_Mark); 69 | 70 | procedure Put (Item : in Num; 71 | Pic : in Picture; 72 | Currency : in Wide_String := Default_Currency; 73 | Fill : in Wide_Character := Default_Fill; 74 | Separator : in Wide_Character := Default_Separator; 75 | Radix_Mark : in Wide_Character := Default_Radix_Mark); 76 | 77 | procedure Put (To : out Wide_String; 78 | Item : in Num; 79 | Pic : in Picture; 80 | Currency : in Wide_String := Default_Currency; 81 | Fill : in Wide_Character := Default_Fill; 82 | Separator : in Wide_Character := Default_Separator; 83 | Radix_Mark : in Wide_Character := Default_Radix_Mark); 84 | end Decimal_Output; 85 | 86 | private 87 | pragma Import (Ada, Picture); 88 | end Ada.Wide_Text_IO.Editing; 89 | -------------------------------------------------------------------------------- /ada-strings-wide_maps.ads: -------------------------------------------------------------------------------- 1 | -- Standard Ada library specification 2 | -- Copyright (c) 2003-2018 Maxim Reznik 3 | -- Copyright (c) 2004-2016 AXE Consultants 4 | -- Copyright (c) 2004, 2005, 2006 Ada-Europe 5 | -- Copyright (c) 2000 The MITRE Corporation, Inc. 6 | -- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc. 7 | -- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual 8 | --------------------------------------------------------------------------- 9 | 10 | package Ada.Strings.Wide_Maps is 11 | pragma Preelaborate (Wide_Maps); 12 | 13 | -- Representation for a set of Wide_Character values: 14 | type Wide_Character_Set is private; 15 | pragma Preelaborable_Initialization (Wide_Character_Set); 16 | 17 | Null_Set : constant Wide_Character_Set; 18 | 19 | type Wide_Character_Range is 20 | record 21 | Low : Wide_Character; 22 | High : Wide_Character; 23 | end record; 24 | -- Represents Wide_Character range Low..High 25 | 26 | type Wide_Character_Ranges is array (Positive range <>) 27 | of Wide_Character_Range; 28 | 29 | function To_Set (Ranges : in Wide_Character_Ranges) 30 | return Wide_Character_Set; 31 | 32 | function To_Set (Span : in Wide_Character_Range) 33 | return Wide_Character_Set; 34 | 35 | function To_Ranges (Set : in Wide_Character_Set) 36 | return Wide_Character_Ranges; 37 | 38 | function "=" (Left, Right : in Wide_Character_Set) return Boolean; 39 | 40 | function "not" (Right : in Wide_Character_Set) 41 | return Wide_Character_Set; 42 | function "and" (Left, Right : in Wide_Character_Set) 43 | return Wide_Character_Set; 44 | function "or" (Left, Right : in Wide_Character_Set) 45 | return Wide_Character_Set; 46 | function "xor" (Left, Right : in Wide_Character_Set) 47 | return Wide_Character_Set; 48 | function "-" (Left, Right : in Wide_Character_Set) 49 | return Wide_Character_Set; 50 | 51 | function Is_In (Element : in Wide_Character; 52 | Set : in Wide_Character_Set) 53 | return Boolean; 54 | 55 | function Is_Subset (Elements : in Wide_Character_Set; 56 | Set : in Wide_Character_Set) 57 | return Boolean; 58 | 59 | function "<=" (Left : in Wide_Character_Set; 60 | Right : in Wide_Character_Set) 61 | return Boolean renames Is_Subset; 62 | 63 | -- Alternative representation for a set of Wide_Character values: 64 | subtype Wide_Character_Sequence is Wide_String; 65 | 66 | function To_Set (Sequence : in Wide_Character_Sequence) 67 | return Wide_Character_Set; 68 | 69 | function To_Set (Singleton : in Wide_Character) 70 | return Wide_Character_Set; 71 | 72 | function To_Sequence (Set : in Wide_Character_Set) 73 | return Wide_Character_Sequence; 74 | 75 | -- Representation for a Wide_Character to Wide_Character mapping: 76 | type Wide_Character_Mapping is private; 77 | pragma Preelaborable_Initialization (Wide_Character_Mapping); 78 | 79 | function Value (Map : in Wide_Character_Mapping; 80 | Element : in Wide_Character) 81 | return Wide_Character; 82 | 83 | Identity : constant Wide_Character_Mapping; 84 | 85 | function To_Mapping (From, To : in Wide_Character_Sequence) 86 | return Wide_Character_Mapping; 87 | 88 | function To_Domain (Map : in Wide_Character_Mapping) 89 | return Wide_Character_Sequence; 90 | 91 | function To_Range (Map : in Wide_Character_Mapping) 92 | return Wide_Character_Sequence; 93 | 94 | type Wide_Character_Mapping_Function is 95 | access function (From : in Wide_Character) return Wide_Character; 96 | 97 | private 98 | 99 | pragma Import (Ada, Wide_Character_Set); 100 | pragma Import (Ada, Null_Set); 101 | pragma Import (Ada, Wide_Character_Mapping); 102 | pragma Import (Ada, Identity); 103 | 104 | end Ada.Strings.Wide_Maps; 105 | 106 | 107 | 108 | --------------------------------------------------------------------------------