tree checksum vpatch file split hunks
all signers: ave1
antecedents:
press order:
| zfp_genesis | ave1 |
patch:
(0 . 0)(1 . 1)
5 This is an alternate runtime for GNAT, specific for linux systems.
-(0 . 0)(1 . 54)
10 ------------------------------------------------------------------------------
11 ------------------------------------------------------------------------------
12 -- You do not have, nor can you ever acquire the right to use, copy or --
13 -- distribute this software ; Should you use this software for any purpose, --
14 -- or copy and distribute it to anyone or in any manner, you are breaking --
15 -- the laws of whatever soi-disant jurisdiction, and you promise to --
16 -- continue doing so for the indefinite future. In any case, please --
17 -- always : read and understand any software ; verify any PGP signatures --
18 -- that you use - for any purpose. --
19 -- --
20 -- See also http://trilema.com/2015/a-new-software-licensing-paradigm . --
21 ------------------------------------------------------------------------------
22 ------------------------------------------------------------------------------
23
24 -- Version for use with C run time
25 with Ada.Text_IO; use Ada.Text_IO;
26
27 package body Ada.Integer_Text_IO is
28
29 ---------
30 -- Put --
31 ---------
32
33 procedure Put (X : Integer) is
34 Neg_X : Integer;
35 S : String (1 .. Integer'Width);
36 First : Natural := S'Last + 1;
37 Val : Integer;
38
39 begin
40 -- Work on negative values to avoid overflows
41
42 Neg_X := (if X < 0 then X else -X);
43
44 loop
45 -- Cf RM 4.5.5 Multiplying Operators. The rem operator will return
46 -- negative values for negative values of Neg_X.
47
48 Val := Neg_X rem 10;
49 Neg_X := (Neg_X - Val) / 10;
50 First := First - 1;
51 S (First) := Character'Val (Character'Pos ('0') - Val);
52 exit when Neg_X = 0;
53 end loop;
54
55 if X < 0 then
56 First := First - 1;
57 S (First) := '-';
58 end if;
59
60 Put (S (First .. S'Last));
61 end Put;
62
63 end Ada.Integer_Text_IO;
-(0 . 0)(1 . 22)
68 ------------------------------------------------------------------------------
69 ------------------------------------------------------------------------------
70 -- You do not have, nor can you ever acquire the right to use, copy or --
71 -- distribute this software ; Should you use this software for any purpose, --
72 -- or copy and distribute it to anyone or in any manner, you are breaking --
73 -- the laws of whatever soi-disant jurisdiction, and you promise to --
74 -- continue doing so for the indefinite future. In any case, please --
75 -- always : read and understand any software ; verify any PGP signatures --
76 -- that you use - for any purpose. --
77 -- --
78 -- See also http://trilema.com/2015/a-new-software-licensing-paradigm . --
79 ------------------------------------------------------------------------------
80 ------------------------------------------------------------------------------
81
82 package Ada.Integer_Text_IO is
83
84 procedure Put (X : Integer);
85 -- Output integer to the console
86
87 private
88 pragma Inline_Always (Put);
89 end Ada.Integer_Text_IO;
-(0 . 0)(1 . 59)
94 ------------------------------------------------------------------------------
95 ------------------------------------------------------------------------------
96 -- You do not have, nor can you ever acquire the right to use, copy or --
97 -- distribute this software ; Should you use this software for any purpose, --
98 -- or copy and distribute it to anyone or in any manner, you are breaking --
99 -- the laws of whatever soi-disant jurisdiction, and you promise to --
100 -- continue doing so for the indefinite future. In any case, please --
101 -- always : read and understand any software ; verify any PGP signatures --
102 -- that you use - for any purpose. --
103 -- --
104 -- See also http://trilema.com/2015/a-new-software-licensing-paradigm . --
105 ------------------------------------------------------------------------------
106 ------------------------------------------------------------------------------
107
108 -- Version for use with C run time
109
110 package body Ada.Text_IO is
111
112 --------------
113 -- New_Line --
114 --------------
115
116 procedure New_Line is
117 begin
118 Put (ASCII.LF);
119 end New_Line;
120
121 ---------
122 -- Put --
123 ---------
124
125 procedure Put (Item : Character) is
126 function Putchar (C : Integer) return Integer;
127 pragma Import (C, Putchar);
128
129 Ignore : Integer;
130
131 begin
132 Ignore := Putchar (Character'Pos (Item));
133 end Put;
134
135 procedure Put (Item : String) is
136 begin
137 for J in Item'Range loop
138 Put (Item (J));
139 end loop;
140 end Put;
141
142 --------------
143 -- Put_Line --
144 --------------
145
146 procedure Put_Line (Item : String) is
147 begin
148 Put (Item);
149 New_Line;
150 end Put_Line;
151
152 end Ada.Text_IO;
-(0 . 0)(1 . 33)
157 ------------------------------------------------------------------------------
158 ------------------------------------------------------------------------------
159 -- You do not have, nor can you ever acquire the right to use, copy or --
160 -- distribute this software ; Should you use this software for any purpose, --
161 -- or copy and distribute it to anyone or in any manner, you are breaking --
162 -- the laws of whatever soi-disant jurisdiction, and you promise to --
163 -- continue doing so for the indefinite future. In any case, please --
164 -- always : read and understand any software ; verify any PGP signatures --
165 -- that you use - for any purpose. --
166 -- --
167 -- See also http://trilema.com/2015/a-new-software-licensing-paradigm . --
168 ------------------------------------------------------------------------------
169 ------------------------------------------------------------------------------
170
171 package Ada.Text_IO is
172
173 procedure Put (Item : Character);
174 -- Output character to the console
175
176 procedure Put (Item : String);
177 -- Output string to the console
178
179 procedure Put_Line (Item : String);
180 -- Output string followed by new line to the console
181
182 procedure New_Line;
183 -- Output new line character to the console
184
185 private
186 pragma Inline_Always (Put);
187 pragma Inline_Always (Put_Line);
188 pragma Inline_Always (New_Line);
189 end Ada.Text_IO;
-(0 . 0)(1 . 18)
194 ------------------------------------------------------------------------------
195 ------------------------------------------------------------------------------
196 -- You do not have, nor can you ever acquire the right to use, copy or --
197 -- distribute this software ; Should you use this software for any purpose, --
198 -- or copy and distribute it to anyone or in any manner, you are breaking --
199 -- the laws of whatever soi-disant jurisdiction, and you promise to --
200 -- continue doing so for the indefinite future. In any case, please --
201 -- always : read and understand any software ; verify any PGP signatures --
202 -- that you use - for any purpose. --
203 -- --
204 -- See also http://trilema.com/2015/a-new-software-licensing-paradigm . --
205 ------------------------------------------------------------------------------
206 ------------------------------------------------------------------------------
207
208 package Ada is
209 pragma Pure;
210
211 end Ada;
-(0 . 0)(1 . 163)
216 ------------------------------------------------------------------------------
217 ------------------------------------------------------------------------------
218 -- You do not have, nor can you ever acquire the right to use, copy or --
219 -- distribute this software ; Should you use this software for any purpose, --
220 -- or copy and distribute it to anyone or in any manner, you are breaking --
221 -- the laws of whatever soi-disant jurisdiction, and you promise to --
222 -- continue doing so for the indefinite future. In any case, please --
223 -- always : read and understand any software ; verify any PGP signatures --
224 -- that you use - for any purpose. --
225 -- --
226 -- See also http://trilema.com/2015/a-new-software-licensing-paradigm . --
227 ------------------------------------------------------------------------------
228 ------------------------------------------------------------------------------
229
230 pragma Compiler_Unit_Warning;
231
232 package Interfaces is
233 pragma No_Elaboration_Code_All;
234 pragma Pure;
235
236 -- All identifiers in this unit are implementation defined
237
238 pragma Implementation_Defined;
239
240 type Integer_8 is range -2 ** 7 .. 2 ** 7 - 1;
241 for Integer_8'Size use 8;
242
243 type Integer_16 is range -2 ** 15 .. 2 ** 15 - 1;
244 for Integer_16'Size use 16;
245
246 type Integer_32 is range -2 ** 31 .. 2 ** 31 - 1;
247 for Integer_32'Size use 32;
248
249 type Integer_64 is new Long_Long_Integer;
250 for Integer_64'Size use 64;
251 -- Note: we use Long_Long_Integer'First instead of -2 ** 63 to allow this
252 -- unit to compile when using custom target configuration files where the
253 -- maximum integer is 32 bits. This is useful for static analysis tools
254 -- such as SPARK or CodePeer. In the normal case Long_Long_Integer is
255 -- always 64-bits so we get the desired 64-bit type.
256
257 type Unsigned_8 is mod 2 ** 8;
258 for Unsigned_8'Size use 8;
259
260 type Unsigned_16 is mod 2 ** 16;
261 for Unsigned_16'Size use 16;
262
263 type Unsigned_24 is mod 2 ** 24;
264 for Unsigned_24'Size use 24;
265 -- Declare this type for compatibility with legacy Ada compilers.
266 -- This is particularly useful in the context of CodePeer analysis.
267
268 type Unsigned_32 is mod 2 ** 32;
269 for Unsigned_32'Size use 32;
270
271 type Unsigned_64 is mod 2 ** Long_Long_Integer'Size;
272 for Unsigned_64'Size use 64;
273 -- See comment on Integer_64 above
274
275 function Shift_Left
276 (Value : Unsigned_8;
277 Amount : Natural) return Unsigned_8;
278
279 function Shift_Right
280 (Value : Unsigned_8;
281 Amount : Natural) return Unsigned_8;
282
283 function Shift_Right_Arithmetic
284 (Value : Unsigned_8;
285 Amount : Natural) return Unsigned_8;
286
287 function Rotate_Left
288 (Value : Unsigned_8;
289 Amount : Natural) return Unsigned_8;
290
291 function Rotate_Right
292 (Value : Unsigned_8;
293 Amount : Natural) return Unsigned_8;
294
295 function Shift_Left
296 (Value : Unsigned_16;
297 Amount : Natural) return Unsigned_16;
298
299 function Shift_Right
300 (Value : Unsigned_16;
301 Amount : Natural) return Unsigned_16;
302
303 function Shift_Right_Arithmetic
304 (Value : Unsigned_16;
305 Amount : Natural) return Unsigned_16;
306
307 function Rotate_Left
308 (Value : Unsigned_16;
309 Amount : Natural) return Unsigned_16;
310
311 function Rotate_Right
312 (Value : Unsigned_16;
313 Amount : Natural) return Unsigned_16;
314
315 function Shift_Left
316 (Value : Unsigned_32;
317 Amount : Natural) return Unsigned_32;
318
319 function Shift_Right
320 (Value : Unsigned_32;
321 Amount : Natural) return Unsigned_32;
322
323 function Shift_Right_Arithmetic
324 (Value : Unsigned_32;
325 Amount : Natural) return Unsigned_32;
326
327 function Rotate_Left
328 (Value : Unsigned_32;
329 Amount : Natural) return Unsigned_32;
330
331 function Rotate_Right
332 (Value : Unsigned_32;
333 Amount : Natural) return Unsigned_32;
334
335 function Shift_Left
336 (Value : Unsigned_64;
337 Amount : Natural) return Unsigned_64;
338
339 function Shift_Right
340 (Value : Unsigned_64;
341 Amount : Natural) return Unsigned_64;
342
343 function Shift_Right_Arithmetic
344 (Value : Unsigned_64;
345 Amount : Natural) return Unsigned_64;
346
347 function Rotate_Left
348 (Value : Unsigned_64;
349 Amount : Natural) return Unsigned_64;
350
351 function Rotate_Right
352 (Value : Unsigned_64;
353 Amount : Natural) return Unsigned_64;
354
355 pragma Import (Intrinsic, Shift_Left);
356 pragma Import (Intrinsic, Shift_Right);
357 pragma Import (Intrinsic, Shift_Right_Arithmetic);
358 pragma Import (Intrinsic, Rotate_Left);
359 pragma Import (Intrinsic, Rotate_Right);
360
361 -- IEEE Floating point types
362
363 type IEEE_Float_32 is digits 6;
364 for IEEE_Float_32'Size use 32;
365
366 type IEEE_Float_64 is digits 15;
367 for IEEE_Float_64'Size use 64;
368
369 -- If there is an IEEE extended float available on the machine, we assume
370 -- that it is available as Long_Long_Float.
371
372 -- Note: it is harmless, and explicitly permitted, to include additional
373 -- types in interfaces, so it is not wrong to have IEEE_Extended_Float
374 -- defined even if the extended format is not available.
375
376 type IEEE_Extended_Float is new Long_Long_Float;
377
378 end Interfaces;
-(0 . 0)(1 . 45)
383 ------------------------------------------------------------------------------
384 ------------------------------------------------------------------------------
385 -- You do not have, nor can you ever acquire the right to use, copy or --
386 -- distribute this software ; Should you use this software for any purpose, --
387 -- or copy and distribute it to anyone or in any manner, you are breaking --
388 -- the laws of whatever soi-disant jurisdiction, and you promise to --
389 -- continue doing so for the indefinite future. In any case, please --
390 -- always : read and understand any software ; verify any PGP signatures --
391 -- that you use - for any purpose. --
392 -- --
393 -- See also http://trilema.com/2015/a-new-software-licensing-paradigm . --
394 ------------------------------------------------------------------------------
395 ------------------------------------------------------------------------------
396
397 with Ada.Text_IO; use Ada.Text_IO;
398 with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
399 with System.Storage_Elements; use System.Storage_Elements;
400
401 procedure Last_Chance_Handler
402 (Msg : System.Address; Line : Integer)
403 is
404 procedure Exit_Now(status: Integer);
405 pragma Import
406 (Convention => C,
407 Entity => Exit_Now,
408 External_Name => "exit");
409
410 function Peek (Addr : System.Address) return Character
411 is
412 C : Character with Address => Addr;
413 begin
414 return C;
415 end Peek;
416 A : System.Address := Msg;
417 begin
418 Put ("GNAT Exception!:");
419 Put (Line);
420 Put (":");
421 while Peek(A) /= ASCII.NUL loop
422 Put (Peek(A));
423 A := A + 1;
424 end loop;
425 New_Line;
426 Exit_Now(-1);
427 end Last_Chance_Handler;
-(0 . 0)(1 . 19)
432 ------------------------------------------------------------------------------
433 ------------------------------------------------------------------------------
434 -- You do not have, nor can you ever acquire the right to use, copy or --
435 -- distribute this software ; Should you use this software for any purpose, --
436 -- or copy and distribute it to anyone or in any manner, you are breaking --
437 -- the laws of whatever soi-disant jurisdiction, and you promise to --
438 -- continue doing so for the indefinite future. In any case, please --
439 -- always : read and understand any software ; verify any PGP signatures --
440 -- that you use - for any purpose. --
441 -- --
442 -- See also http://trilema.com/2015/a-new-software-licensing-paradigm . --
443 ------------------------------------------------------------------------------
444 ------------------------------------------------------------------------------
445
446 with System;
447
448 procedure Last_Chance_Handler
449 (Msg : System.Address; Line : Integer);
450 pragma Export (C, Last_Chance_Handler, "__gnat_last_chance_handler");
-(0 . 0)(1 . 55)
455 ------------------------------------------------------------------------------
456 ------------------------------------------------------------------------------
457 -- You do not have, nor can you ever acquire the right to use, copy or --
458 -- distribute this software ; Should you use this software for any purpose, --
459 -- or copy and distribute it to anyone or in any manner, you are breaking --
460 -- the laws of whatever soi-disant jurisdiction, and you promise to --
461 -- continue doing so for the indefinite future. In any case, please --
462 -- always : read and understand any software ; verify any PGP signatures --
463 -- that you use - for any purpose. --
464 -- --
465 -- See also http://trilema.com/2015/a-new-software-licensing-paradigm . --
466 ------------------------------------------------------------------------------
467 ------------------------------------------------------------------------------
468
469 package body System.Elaboration_Allocators is
470
471 Elaboration_In_Progress : Boolean;
472 pragma Atomic (Elaboration_In_Progress);
473 -- Flag to show if elaboration is active. We don't attempt to initialize
474 -- this because we want to be sure it gets reset if we are in a multiple
475 -- elaboration situation of some kind. Make it atomic to prevent race
476 -- conditions of any kind (not clearly necessary, but harmless!)
477
478 ------------------------------
479 -- Check_Standard_Allocator --
480 ------------------------------
481
482 procedure Check_Standard_Allocator is
483 begin
484 if not Elaboration_In_Progress then
485 raise Program_Error with
486 "standard allocator after elaboration is complete is not allowed "
487 & "(No_Standard_Allocators_After_Elaboration restriction active)";
488 end if;
489 end Check_Standard_Allocator;
490
491 -----------------------------
492 -- Mark_End_Of_Elaboration --
493 -----------------------------
494
495 procedure Mark_End_Of_Elaboration is
496 begin
497 Elaboration_In_Progress := False;
498 end Mark_End_Of_Elaboration;
499
500 -------------------------------
501 -- Mark_Start_Of_Elaboration --
502 -------------------------------
503
504 procedure Mark_Start_Of_Elaboration is
505 begin
506 Elaboration_In_Progress := True;
507 end Mark_Start_Of_Elaboration;
508
509 end System.Elaboration_Allocators;
-(0 . 0)(1 . 40)
514 ------------------------------------------------------------------------------
515 ------------------------------------------------------------------------------
516 -- You do not have, nor can you ever acquire the right to use, copy or --
517 -- distribute this software ; Should you use this software for any purpose, --
518 -- or copy and distribute it to anyone or in any manner, you are breaking --
519 -- the laws of whatever soi-disant jurisdiction, and you promise to --
520 -- continue doing so for the indefinite future. In any case, please --
521 -- always : read and understand any software ; verify any PGP signatures --
522 -- that you use - for any purpose. --
523 -- --
524 -- See also http://trilema.com/2015/a-new-software-licensing-paradigm . --
525 ------------------------------------------------------------------------------
526 ------------------------------------------------------------------------------
527
528 -- This package provides the interfaces for proper handling of restriction
529 -- No_Standard_Allocators_After_Elaboration. It is used only by programs
530 -- which use this restriction.
531
532 package System.Elaboration_Allocators is
533 pragma Preelaborate;
534
535 procedure Mark_Start_Of_Elaboration;
536 -- Called right at the start of main elaboration if the program activates
537 -- restriction No_Standard_Allocators_After_Elaboration. We don't want to
538 -- rely on the normal elaboration mechanism for marking this event, since
539 -- that would require us to be sure to elaborate this first, which would
540 -- be awkward, and it is convenient to have this package be Preelaborate.
541
542 procedure Mark_End_Of_Elaboration;
543 -- Called when main elaboration is complete if the program has activated
544 -- restriction No_Standard_Allocators_After_Elaboration. This is the point
545 -- beyond which any standard allocator use will violate the restriction.
546
547 procedure Check_Standard_Allocator;
548 -- Called as part of every allocator in a program for which the restriction
549 -- No_Standard_Allocators_After_Elaboration is active. This will raise an
550 -- exception (Program_Error with an appropriate message) if it is called
551 -- after the call to Mark_End_Of_Elaboration.
552
553 end System.Elaboration_Allocators;
-(0 . 0)(1 . 65)
558 ------------------------------------------------------------------------------
559 ------------------------------------------------------------------------------
560 -- You do not have, nor can you ever acquire the right to use, copy or --
561 -- distribute this software ; Should you use this software for any purpose, --
562 -- or copy and distribute it to anyone or in any manner, you are breaking --
563 -- the laws of whatever soi-disant jurisdiction, and you promise to --
564 -- continue doing so for the indefinite future. In any case, please --
565 -- always : read and understand any software ; verify any PGP signatures --
566 -- that you use - for any purpose. --
567 -- --
568 -- See also http://trilema.com/2015/a-new-software-licensing-paradigm . --
569 ------------------------------------------------------------------------------
570 ------------------------------------------------------------------------------
571
572 -- This is the default (used on all native platforms) version of this package
573
574 pragma Compiler_Unit_Warning;
575
576 package body System.Parameters is
577
578 -------------------------
579 -- Adjust_Storage_Size --
580 -------------------------
581
582 function Adjust_Storage_Size (Size : Size_Type) return Size_Type is
583 begin
584 if Size = Unspecified_Size then
585 return Default_Stack_Size;
586 elsif Size < Minimum_Stack_Size then
587 return Minimum_Stack_Size;
588 else
589 return Size;
590 end if;
591 end Adjust_Storage_Size;
592
593 ------------------------
594 -- Default_Stack_Size --
595 ------------------------
596
597 function Default_Stack_Size return Size_Type is
598 Default_Stack_Size : Integer;
599 pragma Import (C, Default_Stack_Size, "__gl_default_stack_size");
600 begin
601 if Default_Stack_Size = -1 then
602 return 2 * 1024 * 1024;
603 else
604 return Size_Type (Default_Stack_Size);
605 end if;
606 end Default_Stack_Size;
607
608 ------------------------
609 -- Minimum_Stack_Size --
610 ------------------------
611
612 function Minimum_Stack_Size return Size_Type is
613 begin
614 -- 12K is required for stack-checking to work reliably on most platforms
615 -- when using the GCC scheme to propagate an exception in the ZCX case.
616 -- 16K is the value of PTHREAD_STACK_MIN under Linux, so is a reasonable
617 -- default.
618
619 return 16 * 1024;
620 end Minimum_Stack_Size;
621
622 end System.Parameters;
-(0 . 0)(1 . 193)
627 ------------------------------------------------------------------------------
628 ------------------------------------------------------------------------------
629 -- You do not have, nor can you ever acquire the right to use, copy or --
630 -- distribute this software ; Should you use this software for any purpose, --
631 -- or copy and distribute it to anyone or in any manner, you are breaking --
632 -- the laws of whatever soi-disant jurisdiction, and you promise to --
633 -- continue doing so for the indefinite future. In any case, please --
634 -- always : read and understand any software ; verify any PGP signatures --
635 -- that you use - for any purpose. --
636 -- --
637 -- See also http://trilema.com/2015/a-new-software-licensing-paradigm . --
638 ------------------------------------------------------------------------------
639 ------------------------------------------------------------------------------
640
641 -- Default version used when no target-specific version is provided
642
643 -- This package defines some system dependent parameters for GNAT. These
644 -- are values that are referenced by the runtime library and are therefore
645 -- relevant to the target machine.
646
647 -- The parameters whose value is defined in the spec are not generally
648 -- expected to be changed. If they are changed, it will be necessary to
649 -- recompile the run-time library.
650
651 -- The parameters which are defined by functions can be changed by modifying
652 -- the body of System.Parameters in file s-parame.adb. A change to this body
653 -- requires only rebinding and relinking of the application.
654
655 -- Note: do not introduce any pragma Inline statements into this unit, since
656 -- otherwise the relinking and rebinding capability would be deactivated.
657
658 pragma Compiler_Unit_Warning;
659
660 package System.Parameters is
661 pragma Pure;
662
663 ---------------------------------------
664 -- Task And Stack Allocation Control --
665 ---------------------------------------
666
667 type Task_Storage_Size is new Integer;
668 -- Type used in tasking units for task storage size
669
670 type Size_Type is new Task_Storage_Size;
671 -- Type used to provide task storage size to runtime
672
673 Unspecified_Size : constant Size_Type := Size_Type'First;
674 -- Value used to indicate that no size type is set
675
676 subtype Percentage is Size_Type range -1 .. 100;
677 Dynamic : constant Size_Type := -1;
678 -- The secondary stack ratio is a constant between 0 and 100 which
679 -- determines the percentage of the allocated task stack that is
680 -- used by the secondary stack (the rest being the primary stack).
681 -- The special value of minus one indicates that the secondary
682 -- stack is to be allocated from the heap instead.
683
684 Sec_Stack_Percentage : constant Percentage := Dynamic;
685 -- This constant defines the handling of the secondary stack
686
687 Sec_Stack_Dynamic : constant Boolean := Sec_Stack_Percentage = Dynamic;
688 -- Convenient Boolean for testing for dynamic secondary stack
689
690 function Default_Stack_Size return Size_Type;
691 -- Default task stack size used if none is specified
692
693 function Minimum_Stack_Size return Size_Type;
694 -- Minimum task stack size permitted
695
696 function Adjust_Storage_Size (Size : Size_Type) return Size_Type;
697 -- Given the storage size stored in the TCB, return the Storage_Size
698 -- value required by the RM for the Storage_Size attribute. The
699 -- required adjustment is as follows:
700 --
701 -- when Size = Unspecified_Size, return Default_Stack_Size
702 -- when Size < Minimum_Stack_Size, return Minimum_Stack_Size
703 -- otherwise return given Size
704
705 Default_Env_Stack_Size : constant Size_Type := 8_192_000;
706 -- Assumed size of the environment task, if no other information
707 -- is available. This value is used when stack checking is
708 -- enabled and no GNAT_STACK_LIMIT environment variable is set.
709
710 Stack_Grows_Down : constant Boolean := True;
711 -- This constant indicates whether the stack grows up (False) or
712 -- down (True) in memory as functions are called. It is used for
713 -- proper implementation of the stack overflow check.
714
715 ----------------------------------------------
716 -- Characteristics of types in Interfaces.C --
717 ----------------------------------------------
718
719 long_bits : constant := Long_Integer'Size;
720 -- Number of bits in type long and unsigned_long. The normal convention
721 -- is that this is the same as type Long_Integer, but this may not be true
722 -- of all targets.
723
724 ptr_bits : constant := Standard'Address_Size;
725 subtype C_Address is System.Address;
726 -- Number of bits in Interfaces.C pointers, normally a standard address
727
728 C_Malloc_Linkname : constant String := "__gnat_malloc";
729 -- Name of runtime function used to allocate such a pointer
730
731 ----------------------------------------------
732 -- Behavior of Pragma Finalize_Storage_Only --
733 ----------------------------------------------
734
735 -- Garbage_Collected is a Boolean constant whose value indicates the
736 -- effect of the pragma Finalize_Storage_Entry on a controlled type.
737
738 -- Garbage_Collected = False
739
740 -- The system releases all storage on program termination only,
741 -- but not other garbage collection occurs, so finalization calls
742 -- are omitted only for outer level objects can be omitted if
743 -- pragma Finalize_Storage_Only is used.
744
745 -- Garbage_Collected = True
746
747 -- The system provides full garbage collection, so it is never
748 -- necessary to release storage for controlled objects for which
749 -- a pragma Finalize_Storage_Only is used.
750
751 Garbage_Collected : constant Boolean := False;
752 -- The storage mode for this system (release on program exit)
753
754 ---------------------
755 -- Tasking Profile --
756 ---------------------
757
758 -- In the following sections, constant parameters are defined to
759 -- allow some optimizations and fine tuning within the tasking run time
760 -- based on restrictions on the tasking features.
761
762 ----------------------
763 -- Locking Strategy --
764 ----------------------
765
766 Single_Lock : constant Boolean := False;
767 -- Indicates whether a single lock should be used within the tasking
768 -- run-time to protect internal structures. If True, a single lock
769 -- will be used, meaning less locking/unlocking operations, but also
770 -- more global contention. In general, Single_Lock should be set to
771 -- True on single processor machines, and to False to multi-processor
772 -- systems, but this can vary from application to application and also
773 -- depends on the scheduling policy.
774
775 -------------------
776 -- Task Abortion --
777 -------------------
778
779 No_Abort : constant Boolean := False;
780 -- This constant indicates whether abort statements and asynchronous
781 -- transfer of control (ATC) are disallowed. If set to True, it is
782 -- assumed that neither construct is used, and the run time does not
783 -- need to defer/undefer abort and check for pending actions at
784 -- completion points. A value of True for No_Abort corresponds to:
785 -- pragma Restrictions (No_Abort_Statements);
786 -- pragma Restrictions (Max_Asynchronous_Select_Nesting => 0);
787
788 ---------------------
789 -- Task Attributes --
790 ---------------------
791
792 Max_Attribute_Count : constant := 32;
793 -- Number of task attributes stored in the task control block
794
795 --------------------
796 -- Runtime Traces --
797 --------------------
798
799 Runtime_Traces : constant Boolean := False;
800 -- This constant indicates whether the runtime outputs traces to a
801 -- predefined output or not (True means that traces are output).
802 -- See System.Traces for more details.
803
804 -----------------------
805 -- Task Image Length --
806 -----------------------
807
808 Max_Task_Image_Length : constant := 256;
809 -- This constant specifies the maximum length of a task's image
810
811 ------------------------------
812 -- Exception Message Length --
813 ------------------------------
814
815 Default_Exception_Msg_Max_Length : constant := 200;
816 -- This constant specifies the default number of characters to allow
817 -- in an exception message (200 is minimum required by RM 11.4.1(18)).
818
819 end System.Parameters;
-(0 . 0)(1 . 135)
824 ------------------------------------------------------------------------------
825 ------------------------------------------------------------------------------
826 -- You do not have, nor can you ever acquire the right to use, copy or --
827 -- distribute this software ; Should you use this software for any purpose, --
828 -- or copy and distribute it to anyone or in any manner, you are breaking --
829 -- the laws of whatever soi-disant jurisdiction, and you promise to --
830 -- continue doing so for the indefinite future. In any case, please --
831 -- always : read and understand any software ; verify any PGP signatures --
832 -- that you use - for any purpose. --
833 -- --
834 -- See also http://trilema.com/2015/a-new-software-licensing-paradigm . --
835 ------------------------------------------------------------------------------
836 ------------------------------------------------------------------------------
837
838 package System is
839 pragma Pure;
840 -- Note that we take advantage of the implementation permission to make
841 -- this unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada
842 -- 2005, this is Pure in any case (AI-362).
843
844 pragma No_Elaboration_Code_All;
845 -- Allow the use of that restriction in units that WITH this unit
846
847 type Name is (SYSTEM_NAME_GNAT);
848 System_Name : constant Name := SYSTEM_NAME_GNAT;
849
850 -- System-Dependent Named Numbers
851
852 Min_Int : constant := Long_Long_Integer'First;
853 Max_Int : constant := Long_Long_Integer'Last;
854
855 Max_Binary_Modulus : constant := 2 ** Long_Long_Integer'Size;
856 Max_Nonbinary_Modulus : constant := 2 ** Integer'Size - 1;
857
858 Max_Base_Digits : constant := Long_Long_Float'Digits;
859 Max_Digits : constant := Long_Long_Float'Digits;
860
861 Max_Mantissa : constant := 63;
862 Fine_Delta : constant := 2.0 ** (-Max_Mantissa);
863
864 Tick : constant := 0.000_001;
865
866 -- Storage-related Declarations
867
868 type Address is private;
869 pragma Preelaborable_Initialization (Address);
870 Null_Address : constant Address;
871
872 Storage_Unit : constant := 8;
873 Word_Size : constant := Standard'Word_Size;
874 Memory_Size : constant := 2 ** Word_Size;
875
876 -- Address comparison
877
878 function "<" (Left, Right : Address) return Boolean;
879 function "<=" (Left, Right : Address) return Boolean;
880 function ">" (Left, Right : Address) return Boolean;
881 function ">=" (Left, Right : Address) return Boolean;
882 function "=" (Left, Right : Address) return Boolean;
883
884 pragma Import (Intrinsic, "<");
885 pragma Import (Intrinsic, "<=");
886 pragma Import (Intrinsic, ">");
887 pragma Import (Intrinsic, ">=");
888 pragma Import (Intrinsic, "=");
889
890 -- Other System-Dependent Declarations
891
892 type Bit_Order is (High_Order_First, Low_Order_First);
893 Default_Bit_Order : constant Bit_Order := Low_Order_First;
894 pragma Warnings (Off, Default_Bit_Order); -- kill constant condition warning
895
896 -- Priority-related Declarations (RM D.1)
897
898 -- 0 .. 98 corresponds to the system priority range 1 .. 99.
899 --
900 -- If the scheduling policy is SCHED_FIFO or SCHED_RR the runtime makes use
901 -- of the entire range provided by the system.
902 --
903 -- If the scheduling policy is SCHED_OTHER the only valid system priority
904 -- is 1 and other values are simply ignored.
905
906 Max_Priority : constant Positive := 97;
907 Max_Interrupt_Priority : constant Positive := 98;
908
909 subtype Any_Priority is Integer range 0 .. 98;
910 subtype Priority is Any_Priority range 0 .. 97;
911 subtype Interrupt_Priority is Any_Priority range 98 .. 98;
912
913 Default_Priority : constant Priority := 48;
914
915 private
916
917 type Address is mod Memory_Size;
918 Null_Address : constant Address := 0;
919
920 --------------------------------------
921 -- System Implementation Parameters --
922 --------------------------------------
923
924 -- These parameters provide information about the target that is used
925 -- by the compiler. They are in the private part of System, where they
926 -- can be accessed using the special circuitry in the Targparm unit
927 -- whose source should be consulted for more detailed descriptions
928 -- of the individual switch values.
929
930 Backend_Divide_Checks : constant Boolean := False;
931 Backend_Overflow_Checks : constant Boolean := True;
932 Command_Line_Args : constant Boolean := False;
933 Configurable_Run_Time : constant Boolean := True;
934 Denorm : constant Boolean := True;
935 Duration_32_Bits : constant Boolean := False;
936 Exit_Status_Supported : constant Boolean := True;
937 Fractional_Fixed_Ops : constant Boolean := False;
938 Frontend_Layout : constant Boolean := False;
939 Machine_Overflows : constant Boolean := False;
940 Machine_Rounds : constant Boolean := True;
941 Preallocated_Stacks : constant Boolean := False;
942 Signed_Zeros : constant Boolean := True;
943 Stack_Check_Default : constant Boolean := False;
944 Stack_Check_Probes : constant Boolean := True;
945 Stack_Check_Limits : constant Boolean := False;
946 Support_Aggregates : constant Boolean := True;
947 Support_Atomic_Primitives : constant Boolean := True;
948 Support_Composite_Assign : constant Boolean := True;
949 Support_Composite_Compare : constant Boolean := True;
950 Support_Long_Shifts : constant Boolean := True;
951 Always_Compatible_Rep : constant Boolean := False;
952 Suppress_Standard_Library : constant Boolean := True;
953 Use_Ada_Main_Program_Name : constant Boolean := False;
954 Frontend_Exceptions : constant Boolean := False;
955 ZCX_By_Default : constant Boolean := True;
956 Run_Time_Name : constant String := "FFA Run Time";
957
958 end System;
-(0 . 0)(1 . 1)
963 Placeholder.
-(0 . 0)(1 . 38)
968 ------------------------------------------------------------------------------
969 ------------------------------------------------------------------------------
970 -- You do not have, nor can you ever acquire the right to use, copy or --
971 -- distribute this software ; Should you use this software for any purpose, --
972 -- or copy and distribute it to anyone or in any manner, you are breaking --
973 -- the laws of whatever soi-disant jurisdiction, and you promise to --
974 -- continue doing so for the indefinite future. In any case, please --
975 -- always : read and understand any software ; verify any PGP signatures --
976 -- that you use - for any purpose. --
977 -- --
978 -- See also http://trilema.com/2015/a-new-software-licensing-paradigm . --
979 ------------------------------------------------------------------------------
980 ------------------------------------------------------------------------------
981
982 library project Gnat_Runtime is
983 for Languages use ("Ada");
984
985 for Source_Dirs use ("adainclude");
986 for Object_Dir use "obj";
987 for Library_Kind use "static";
988 for Library_Name use "gnat";
989 for Library_Dir use "adalib";
990
991 package Builder is
992 for Default_Switches ("Ada") use (
993 "-x",
994 "-gnatg", "-gnatyN",
995 "-gnatec=" & Gnat_Runtime'Project_Dir & "restrict.adc");
996 end Builder;
997
998 package Compiler is
999 for Default_Switches ("Ada") use (
1000 "-O2",
1001 "-ffunction-sections",
1002 "-fdata-sections");
1003 end Compiler;
1004
1005 end Gnat_Runtime;
-(0 . 0)(1 . 1)
1010 535595 zfp_genesis ave1 a minimal gnat runtime library
-(0 . 0)(1 . 1)
1015 Placeholder.
-(0 . 0)(1 . 79)
1020 ------------------------------------------------------------------------------
1021 ------------------------------------------------------------------------------
1022 -- You do not have, nor can you ever acquire the right to use, copy or --
1023 -- distribute this software ; Should you use this software for any purpose, --
1024 -- or copy and distribute it to anyone or in any manner, you are breaking --
1025 -- the laws of whatever soi-disant jurisdiction, and you promise to --
1026 -- continue doing so for the indefinite future. In any case, please --
1027 -- always : read and understand any software ; verify any PGP signatures --
1028 -- that you use - for any purpose. --
1029 -- --
1030 -- See also http://trilema.com/2015/a-new-software-licensing-paradigm . --
1031 ------------------------------------------------------------------------------
1032 ------------------------------------------------------------------------------
1033
1034 pragma Restrictions(Immediate_Reclamation);
1035 pragma Restrictions(Max_Asynchronous_Select_Nesting => 0);
1036 pragma Restrictions(Max_Protected_Entries => 0);
1037 pragma Restrictions(Max_Select_Alternatives => 0);
1038 pragma Restrictions(Max_Task_Entries => 0);
1039 pragma Restrictions(Max_Tasks => 0);
1040 pragma Restrictions(No_Abort_Statements);
1041 pragma Restrictions(No_Access_Parameter_Allocators);
1042 pragma Restrictions(No_Allocators);
1043 pragma Restrictions(No_Asynchronous_Control);
1044 pragma Restrictions(No_Calendar);
1045 pragma Restrictions(No_Coextensions);
1046 pragma Restrictions(No_Default_Stream_Attributes);
1047 pragma Restrictions(No_Delay);
1048 pragma Restrictions(No_Dispatch);
1049 pragma Restrictions(No_Dispatching_Calls);
1050 pragma Restrictions(No_Dynamic_Attachment);
1051 pragma Restrictions(No_Dynamic_Priorities);
1052 pragma Restrictions(No_Entry_Calls_In_Elaboration_Code);
1053 pragma Restrictions(No_Entry_Queue);
1054 pragma Restrictions(No_Enumeration_Maps);
1055 pragma Restrictions(No_Exception_Propagation);
1056 pragma Restrictions(No_Exception_Registration);
1057 pragma Restrictions(No_Finalization);
1058 pragma Restrictions(No_Fixed_Io);
1059 pragma Restrictions(No_Implementation_Aspect_Specifications);
1060 pragma Restrictions(No_Implementation_Units);
1061 pragma Restrictions(No_Implicit_Conditionals);
1062 pragma Restrictions(No_Implicit_Dynamic_Code);
1063 pragma Restrictions(No_Implicit_Heap_Allocations);
1064 pragma Restrictions(No_Implicit_Protected_Object_Allocations);
1065 pragma Restrictions(No_Implicit_Task_Allocations);
1066 pragma Restrictions(No_Initialize_Scalars);
1067 pragma Restrictions(No_Local_Protected_Objects);
1068 pragma Restrictions(No_Local_Timing_Events);
1069 pragma Restrictions(No_Multiple_Elaboration);
1070 pragma Restrictions(No_Nested_Finalization);
1071 pragma Restrictions(No_Protected_Type_Allocators);
1072 pragma Restrictions(No_Protected_Types);
1073 pragma Restrictions(No_Relative_Delay);
1074 pragma Restrictions(No_Requeue_Statements);
1075 pragma Restrictions(No_Secondary_Stack);
1076 pragma Restrictions(No_Select_Statements);
1077 pragma Restrictions(No_Specific_Termination_Handlers);
1078 pragma Restrictions(No_Standard_Allocators_After_Elaboration);
1079 pragma Restrictions(No_Stream_Optimizations);
1080 pragma Restrictions(No_Streams);
1081 pragma Restrictions(No_Task_Allocators);
1082 pragma Restrictions(No_Task_At_Interrupt_Priority);
1083 pragma Restrictions(No_Task_Attributes_Package);
1084 pragma Restrictions(No_Task_Hierarchy);
1085 pragma Restrictions(No_Tasking);
1086 pragma Restrictions(No_Task_Termination);
1087 pragma Restrictions(No_Terminate_Alternatives);
1088 pragma Restrictions(No_Unchecked_Access);
1089 pragma Restrictions(No_Unchecked_Deallocation);
1090 pragma Restrictions(No_Wide_Characters);
1091 pragma Restrictions(Pure_Barriers);
1092 pragma Restrictions(Simple_Barriers);
1093 pragma Restrictions(Static_Priorities);
1094 pragma Restrictions(Static_Storage_Size);
1095 pragma Validity_Checks(ALL_CHECKS);
1096 pragma Restrictions (No_Enumeration_Maps);
1097 --pragma Restrictions(No_Implicit_Aliasing);
1098 --pragma Restrictions (No_Exceptions);