IFinal - DTICLogin · Maaquafls mi Su. D y, Su" 1204, A*ron, VA 22202-=302 end to dt. office di f ibmu SM R.pAWWy AI.., 01rc di 1. AGENCY USE ONLY (Leave Blank) 12. REPORT IFinal:

R AD-A242 285 N AG FmAppove~ OPM No. 0704-0188

Maaquafls mi Su. D y, Su" 1204, A*ron, VA 22202-=302 end to dt. office di f ibmu SM R.pAWWy AI.., 01rc di

1. AGENCY USE ONLY (Leave Blank) 12. REPORT DATE 3.* REPORT TYPE AND DATES COVERED

IFinal: 29 Nov 1990 to 01 Jun 19934. TITLE AND SUBTITLE I -5. FUNDING NUMBERS

R.R. Software, Inc., IntegrAda 5.1.0 POSIX, Unisys PW/2 386 SCO Unix 3.2 (Host &Target)901 129W1 .1 1086

6. AUTHOR(S)

Wright- Patterson AFB, Dayton, OH 'rr

USA

7. PERFORMING ORGANIZATION NAM E(S) AND ADDRESS(ES) .RMING ORGANIZATION

Ada Validation Facility, Language Control Facility ASD/SCEL " - T NUMBER

Bldg, 676, Rm 135 AVFVSR-434-0891Wright-Patterson AFB, Dayton, OH 45433

9. SPONSORINGiMONITORING AGENCY NAME(S) AND ADDRESS(ES) 10. SPONSORING/MONITORING AGENCY

Ada Joint Program Off ice REPORT NUMBER

United States Department of DefensePentagon, Rm 3E 14Washington, D.C. 20301 -308111. SUPPLEMENTARY NOTES

J ~ ~ ~ '- U________________________

1 2a. DISTRIBUTION/AVAILABILITY STATEMENT 12b. DISTRIBUTION CODE

Approved for public release; distribution unlimited.

13. ABSTRACT (Maximum 200 words)

R.R. Software, Inc., IntegrAda 5.1.0 POSIX, Wright- Patterson AFB, OH, Unisys PW/2 386 SCO Unix 3.2 (Host &Target),ACVC 1.11

91-15047

14. SUBJECT TERMS 15. NUMBER OF PAGES

Ada programming language, Ada Compiler Val. Summary Report, Ada Compiler Val.___________Capability, Val. Testing, Ada Val. Office, Ada Val. Facility, ANSIfMIL-STD-1815A, AJPO. 16. PRICE CODE

17. SECURITY CLASSIFICATION 18. SECURITY CLASSIFICATION 19. SECURITY CLASSIFICATION 20. LIMITATION OF ABSTRACTOF REPORT OF ABSTRACT

UNCLASSIFIED UNCLASSIFED UNCLASSIFIED _________

NSN 7540-01-280-550 Standard Form 298, (Rev. 2-89)PresCribed by ANSI Std. 239-128

AVF Control Number:AVF-VSR-434-08911 August 199190-08-02-RRS

Ada COMPILERVALIDATION SUMMARY REPORT:

Certificate Number: 901129W1.11086R.R. Software, Inc.

IntegrAda 5.1.0 POSIXUnisys PW/2 386 SCO Unix 3.2 -> Unisys PW/2 386 SCO Unix 3.2

Prepared By:Ada Validation Facility

ASD/SCELWright-Patterson AFB OH 45433-6503

' !

.. ... k .. ...

Certificate Information

The following Ada implementation was tested and determined to pass ACVC1.11. Testing was completed on 29 November 1990.

Compiler Name and Version: IntegrAda 5.1.0 POSIX

Host Computer System: Unisys PW/2 386 (under SCO Unix 3.2)

Target Computer System: Unisys PW/2 386 (under SCO Unix 3.2)

Customer Agreement Number: 90-08-02-RRS

See Section 3.1 for any additional information about the testingenvi rornment.

As a result of this validation effort, Validation Certificate901129W1.11086 is awarded to R.R. Software, Inc. This certificate expireson 1 June 1993.

This report has been reviewed and is approved.

6/

Aa Validation FacilitySteven P. WilsonTechnical DirectorASD/SCELWright-Patterson AFB OH 45433-6503

Ada Validation OrganizationDirector, Computer & Software Engineering DivisionInstitute for Defense AnalysesAlexandria VA 22311

Ada Joi OfficeDr. John Solomond, DirectorDepartment of DefenseWashington DC 20301

Declaration of Conformance

Compiler Implementor : R.R. Software, Inc.Ada Validation Facility : Wright-Patterson AFB, Ohio 45433-6503Ada Compiler Validation Capability (ACVC) Version : 1.11

Base Configuration

Ada Compiler Name : IntegrAda Version : 5.1.0 POSIXHost Architecture: Unisys PW/2 386 Host OS & Ver.:SCO Unix 3.2Target Architecture: Unisys PW/2 386 Target OS & Ver.:SCO Unix3.2

Implementor's Declaration

I, the undersigned, representing R.R. Software, Inc. haveimplemented no deliberate extensions to the Ada Language StandardANSI/MIL-STD-1815A in the compiler listed in this declaration. Ideclare that AETECH, Inc. is the owner of record of the Adacompiler listed above, and as such, is responsible for maintainingsaid compiler in conformance to ANSI/MIL-STD-1815A. Allcertificates and registration for Ada language compiler listed inthis declaration shall be made only in the owner's corporate name.

a-.v .4 , /. 1910

,games A: 9ewart DateVice PresidentR.R. Software, Inc.

Owner's Declaration

I, the undersigned, representing AETECH, Inc. take fullresponsibility for implementation and maintenance of the Adacompiler listed above, and agree to the public disclosure of thefinal Validation Summary Report. I declare that all of the Adalanguage compilers listed, and their host/target performance arein compliance with the ANSI/MIL-STD-1815A.

James T. Thomes DatePresident,AETECH, Inc.

TABLE OF CONTENTS

CHAPTER 1 INTRODUCTION

1.1 USE OF THIS VALIDATION SUMMARY REPORT ...... 1-11.2 REFERENCES .................... 1-21.3 ACVC TEST CLASSES ....................... .. 1-21.4 DEFINITION OF TERMS ...... ............... .1-3

CHAPTER 2 IMPLEMENTATION DEPENDENCIES

2.1 WITHDRAWN TESTS ....... ................. .. 2-12.2 INAPPLICABLE TESTS ...... ................ .. 2-12.3 TEST MODIFICATIONS ...... ................ .. 2-4

CHAPTER 3 PROCESSING INFORMATION

3.1 TESTING ENVIRONMENT ..... ............... .. 3-13.2 .......... ......................... .3-13.3 TEST EXECUTION ....... .................. .3-2

APPENDIX A MACRO PARAMETERS

APPENDIX B COMPILATION SYSTEM OPTIONS

APPENDIX C APPENDIX F OF THE Ada STANDARD

CHAPTER 1

INTRODUCTION

The Ada implementation described above was tested according to the AdaValidation Procedures (Pro90] against the Ada Standard (Ada83] using thecurrent Ada Compiler Validation Capability (ACVC). This Validation SummaryReport (VSR) gives an account of the testing of this Ada implementation.For any technical terms used in this report, the reader is referred to[Pro90]. A detailed description of the ACVC may be found in the currentACVC User's Guide (UG89].

1.1 USE OF THIS VALIDATION SUMMARY REPORT

Consistent with the national laws of the originating country, the AdaCertification Body may make full and free public disclosure of this report.In the United States, this is provided in accordance with the "Freedom ofInformation Act" (5 U.S.C. #552). The results of this validation applyonly to the computers, operating systems, and compiler versions identifiedin this report.

The organizations represented on the signature page of this report do notrepresent or warrant that all statements set forth in this report areaccurate and complete, or that the subject implementation has nononconformities to the Ada Standard other than those presented. Copies ofthis report are available to the public from the AVF which performed thisvalidation or from:

National Technical Information Service5285 Port Royal RoadSpringfield VA 22161

Questions regarding this report or the validation test results should bedirected to the AVF which performed this validation or to:

Ada Validation OrganizationInstitute for Defense Analyses1801 North Beauregard StreetAlexandria VA 22311

1-I

INTRODUCTION

1.2 REFERENCES

Reference Manual for the Ada Programming Language, [Ada83]ANSI/MIL-STD-1815A, February 1983 and ISO 8652-1987.

Ada Compiler Validation Procedures, Version 2.1, [Pro90]Ada Joint Program Office, August 1990.

Ada Compiler Validation Capability User's Guide, (UG89] 21 June 1989.

1.3 ACVC TEST CLASSES

Compliance of Ada implementations is tested by means of the ACVC. The ACVCcontains a collection of test programs structured into six test classes:A, B, C, D, E, and L. The first letter of a test name identifies the classto which it belongs. Class A, C, D, and E tests are executable. Class Band class L tests are expected to produce errors at compile time and linktime, respectively.

The executable tests are written in a self-checking manner and produce aPASSED, FAILED, or NOT APPLICABLE message indicating the result when theyare executed. Three Ada library units, the packages REPORT and SPPRT13,and the procedure CHECK FILE are used for this purpose. The package REPORTalso provides a set of identity functions used to defeat some compileroptimizations allowed by the Ada Standard that would circumvent a testobjective. The package SPPRT13 is used by many tests for Chapter 13 of theAda Standard. The procedure CHECK FILE is used to check the contents oftext files written by some of the Class C tests for Chapter 14 of the AdaStandard. The operation of REPORT and CHECK FILE is checked by a set ofexecutable tests. If these units are not opirating correctly, validationtesting is discontinued.

Class B tests check that a compiler detects illegal language usage. ClassB tests are not executable. Each test in this class is compiled and theresulting compilation listing is examined to verify that all violations ofthe Ada Standard are detected. Some of the class B tests contain legal Adacode which must not be flagged illegal by the compiler. This behavior isalso verified.

Class L tests check that an Ada implementation correctly detects violationof the Ada Standard involving multiple, separately compiled units. Errorsare expected at link time, and execution is attempted.

In some tests of the ACVC, certain macro strings have to be replaced byimplementation-specific values - for example, the largest integer. A listof the values used for this implementation is provided in Appendix A. Inaddition to these anticipated test modifications, additional changes may berequired to remove unforeseen conflicts between the tests andimplementation-dependent characteristics. The modifications required forthis implementation are described in section 2.3.

1-2

INTRODUCTION

For each Ada implementation, a customized test suite is produced by theAVF. This customization consists of making the modifications described inthe preceding paragraph, removing withdrawn tests (see section 2.1) and,possibly some inapplicable tests (see Section 2.2 and [UG89]).

In order to pass an ACVC an Ada implementation must process each test ofthe customized test suit-: according to the Ada Standard.

1.4 DEFINITION OF TERMS

Ada Compiler The software and any needed hardware that have to be addedto a given host and target computer system to allowtransformation of Ada programs into executable form andexecution thereof.

Ada Compiler The means for testing compliance of Ada implementations,Validation consisting of the test suite, the support programs, the ACVCCapability user's guide and the template for the validation summary(ACVC) report.

Ada An Ada compiler with its host computer system and itsImplementation target computer system.

Ada Joint The part of the certification body which provides policy andProgram guidance for the Ada certification system.Office (AJPO)

Ada The part of the certification body which carries out theValidation procedures required to establish the compliance of an AdaFacility (AVF) implementation.

Ada The part of the certification body that provides technicalValidation guidance for operations of the Ada certification system.Organization(AVO)

Compliance of The ability of the implementation to pass an ACVC version.an AdaImplementation

Computer A functional unit, consisting of one or more computers andSystem associated software, that uses common storage for all or

part of a program and also for all or part of the datanecessary for the execution of the program; executesuser-written or user-designated programs; performsuser-designated data manipulation, including arithmeticoperations and logic operations; and that can executeprograms that modify themselves during execution. Acomputer system may be. a stand-alone unit or may consist ofseveral inter-connected units.

1-3

INTRODUCTION

Conformity Fulfillment by a product, process or service of allrequirements specified.

Customer An individual or corporate entity who enters into anagreement with an AVF which specifies the terms andconditions for AVF services (of any kind) to be performed.

Declaration of A formal statement from a customer assuring that conformityConformance is realized or attainable on the Ada implementation for

which validation status is realized.

Host Computer A computer system where Ada source programs are transformedSystem into executable form.

Inapplicable A test that contains one or more test objectives found to betest irrelevant for the given Ada implementation.

ISO International Organization for Standardization.

LRM The Ada standard, or Language Reference Manual, published asANSI/MIL-STD-1815A-1983 and ISO 8652-1987. Citations fromthe LRM take the form "<section>.<subsection>:<paragraph>."

Operating Software that controls the execution of programs and thatSystem provides services such as resource allocation, scheduling,

input/output control, and data management. Usually,operating systems are predominantly software, but partial orcomplete hardware implementations are possible.

Target A computer system where the executable form of Ada programsComputer are executed.System

Validated Ada The compiler of a validated Ada implementation.Compiler

Validated Ada An Ada implementation that has been validated successfullyImplementation either by AVF testing or by registration [Pro90].

Validation The process of checking the conformity of an Ada compiler tothe Ada programming language and of issuing a certificatefor this implementation.

withdrawn A test found to be incorrect and not used in conformitytest testing. A test may be incorrect because it has an invalid

test objective, fails to meet its test objective, orcontains erroneous or illegal use of the Ada programminglanguage.

1-4

CHAPTER 2

IMPLEMENTATION DEPENDENCIES

2.1 WITHDRAWN TESTS

The following tests have been withdrawn by the AVO. The rationale forwithdrawing each test is available from either the AVO or the AVF. Thepublication date for this list of withdrawn tests is 21 November 1990.

E28005C B28006C C34006D C35702A B41308B C43004AC45114A C45346A C45612B C45651A C46022A B49008AA74006A C74308A B83022B B83022H B83025B B83025DB83026B C83026A C83041A B85001L C97116A C98003BBA2011A CB7001A CB7001B CB7004A CC1223A BC1226ACC1226B BC3009B BDIB02B BDIB06A ADIB08A BD2AO2ACD2A21E CD2A23E CD2A32A CD2A41A CD2A4lE CD2A87ACD2Bl5C BD3006A BD4008A CD4022A CD4022D CD4024BCD4024C CD4024D CD4031A CD4051D CD5111A CD7004CED7005D CD7005E AD7006A CD7006E AD7201A AD7201ECD7204B BD8002A BD8004C CD9005A CD9005B CDA201ECE2107I CE2117A CE2117B CE2119B CE2205B CE2405ACE3111C CE3116A CE3118A CE3411B CE3412B CE3607BCE3607C CE3607D CE3812A CE3814A CE3902B

2.2 INAPPLICABLE TESTS

A test is inapplicable if it contains test objectives which are irrelevantfor a given Ada implementation. Reasons for a test's inapplicability maybe supported by documents issued by ISO and the AJPO known as AdaCommentaries and commonly referenced in the format AI-ddddd. For thisimplementation, the following tests were determined to be inapplicable forthe reasons indicated; references to Ada Commentaries are included asappropriate.

2-1


The following 201 tests have floating-point type declarations requiringmore digits than SYSTEM.MAXDIGITS:

C24113L..Y (14 tests) C35705L..Y (14 tests)C35706L..Y (14 tests) C35707L..Y (14 tests)C35708L..Y (14 tests) C35802L..Z (15 tests)C45241L..Y (14 tests) C45321L..Y (14 tests)C45421L..Y (14 tests) C45521L..Z (15 tests)C45524L..Z (15 tests) C45621L..Z (15 tests)C45641L..Y (14 tests) C46012L..Z (15 tests)

The following 21 tests check for the predefined type SHORTINTEGER:

C35404B B36105C C45231B C45304B C45411BC45412B C45502B C45503B C45504B C45504EC45611B C45613B C45614B C45631B C45632BB52004E C55B07B B55B09D B86001V C86006DCD7101E

C35404D, C45231D, B86001X, C86006E, and CD710IG check for a predefinedinteger type with a name other than INTEGER, LONGINTEGER, orSHORT INTEGER.

C35702A, C35713B, C45423B, B86001T, and C86006H check for the predefinedtype SHORT FLOAT.

C35713D and B86001Z check for a predefined floating-point type with aname other than FLOAT, LONGFLOAT, or SHORTFLOAT.

C45531M..P (4 tests) and C45532M..P (4 tests) check fixed-pointoperations for types that require a SYSTEM.MAXMANTISSA of 48 orgreater.

C45624A checks that the proper exception is raised if MACHINE OVERFLOWSis FALSE for floating point types with digits 5. For thisimplementation, MACHINEOVERFLOWS is TRUE.

C45624B checks that the proper exception is raised if MACHINEOVERFLSis FALSE for floating point types with digits 6. For thisimplementation, MACHINE OVERFLOWS is TRUE.

D55A03E..H (4 tests) use 31 or more levels of loop nesting which exceedsthe capacity of the compiler.

D56001B uses 65 levels of block nesting which exceeds the capacity ofthe compiler.

D64005F..G (2 tests) use 10 or more levels of recursive procedure callsnesting which exceeds the capacity of the compiler.

B86001Y checks for a predefined fixed-point type other than DURATION.

2-2


C96005B checks for values of type DUR'kTION'BASE that are outside therange of DURATION. There are no such values for this implementation.

LA3004A, LA3004B, EA3004C, EA3004D, CA3004E, and CA3004F check forpragma INLINE for procedures and functions.

CD1009C uses a representation clause specifying a non-default size for afloating-point type.

CD2A84A, CD2A84E, CD2A84I..J (2 tests), and CD2A840 use representationclauses specifying non-default sizes for access types.

BD8001A, BD8003A, BD8004A..B (2 tests), and AD8011A use machine codeinsertions.

AD9004A uses pragma INTERFACE for overloaded subprograms; thisimplementation rejects this use due to calling conventions. (Seesection 2.3.)

CDA201C instantiates Unchecked Conversion with an array type with anon-static index constraint; tHis implementation does not supportUncheckedConversion for types with non-static constraints.

The tests listed in the following table are not applicable because thegiven file operations are supported for the given combination of modeand file access method.

Test File Operation Mode File Access Method

CE2102D CREATE IN FILE SEQUENTIAL 10CE2102E CREATE OUT FILE SEQUENTIALIOCE2102F CREATE IWOUt FILE DIRECI ICE21021 CREATE IN FILE DIRECT-IOCE2102J CREATE OUT FILE DIRECTIOCE2102N OPEN IN FILE SEQUENTIAL 10CE21020 RESET IN -FILE SEQUENTIAL-IOCE2102P OPEN OUT FILE SEQUENTIAL-IOCE2!02Q RESET OUT-FILE SEQUENTIAL-IOCE2102R OPEN INOUT FILE DIRECT 10CE2102S RESET INOUT-FILE DIRECT-IOCE2102T OPEN IN FILE DIRECTIOCE2102U RESET IN FILE DIRECT IOCE2102V OPEN OUT FILE DIRECT-IOCE2102W RESET OUT FILE DIRECT IOCE3102E CREATE IN FILE TEXT 10CE3102F RESET Any Mode TEXT-IOCE3102G DELETE TEXT-IOCE31021 CREATE OUT FILE TEXT 10CE3102J OPEN IN FILE TEXT-IOCE3102K OPEN OUT FILE TEXT-IO

2-3


The following 16 tests check operations on sequential, direct, and textfiles when multiple internal files are associated with the same externalfile and one or more are open for writing; USEERROR is raised when thisassociation is attempted.

CE2107B..E CE2107G..H CE2107L CD2110B CE2110DCE2111D CE2111H CE3111B CE3111D..E CE3114BCE3115A

EE2201D uses instantiations of package SEQUENTIAL IC with unconstrainedarray types; this implementation raises USEERROR--on the attempt tocreate a file of such type.

CE2203A checks that WRITE raises USE ERROR if the capacity of theexternal file is exceeded for SEQUENTIAL_10. This implementation doesnot restrict file capacity.

EE2401D uses instantiations of package DIRECT 10 with unconstrainedarray types; this implementation raises USE_ERROR on the attempt tocreate a file of such type.

CE2403A checks that WRITE raises USE ERROR if the capacity of theexternal file is exceeded for DIRECf-IO. This implementation does notrestrict file capacity.

CE3304A checks that USE ERROR is raised if a call to SET LINE LENGTH orSET PAGE LENGTH specifies a value that is inappropriate -or te externalfile. Tfis implementation does not have inappropriate values for eitherline length or page length.

2.3 TEST MODIFICATIONS

Modifications (see section 1.3) were required for 80 tests.

The following tests were split into two or more tests ber.iuse thisimplementation did not report the violations of the Ada Standard in the wayexpected by the original tests.

B22003A B24007A B24009A B29001A B37106A B51001AB53003A B55AO1A B63001A B63001B B73004B B83003BB83004B B83004C B83004D B83004F B83030D B83EO1CB83EO1D B83EOlE B83E01F B91001H BA1001A BAI001BBA1001C BAI010A BA1010D BA1101A BA1101E BA3006ABA3006B BA3007B BA3008A BA3008B BA3013A BC2001DBC2001E BC3005B BD2B03A BD2DO3A BD4003A

2-4


C85006A..E (5 tests) were graded passed by Test Modification as directed bythe AVO. This implementation generates more object code for these teststhan it can contain in a single compilation unit. Each of these tests wassplit into five equivalent subtests.

The tests below were graded passed by Test Modification as directed by theAVO. These tests all use one of the generic support procedures,LengthCheck or Enum Check (in support files LENCHECK.ADA & ENUMCHEK.ADA),which use the generic procedure Unchecked Conversion. This implementationrejects instantiations of Unchecked Conversion with array types that havenon-static index ranges. The AVO ruled that since this issue was notaddressed by AI-00590, which addresses required support forUnchecked Conversion, and since AI-00590 is considered not binding underACVC 1.11, the support procedures could be modified to remove the use ofUnchecked Conversion. Lines 40..43, 50, and 56..58 in LENCHECK and lines42, 43, anld 58..63 in ENUMCHEK were conmmented out.

CD1009A CD1009I CD1009M CD1009V CD1009W CDIC03ACDlC04D CD2A21A..C CD2A22J CD2A23A..B CD2A24A cD2A31A..CCD2A81A CD3014C CD3014F CD3015C CD3015E.. F CD3015HCD3015K CD3022A CD4061A

BD4006A was graded inapplicable by Evaluation Modification as directed bythe AVO. This test checks that non-static values in component andalignment clauses are rejected; but static alignment values of 8, 16, & 32are assumed to be supported. This implementation supports only values 1 &2; it rejects the clauses at lines 42, 48, 58, and 63, which are not markedas errors.

AD9001B was graded passed by Processing Modification as directed by theAVO. This test checks that, if pragma INTERFACE is supported, no bodiesare required for interfaced subprograms. This implementation requires thatsome foreign bodies exist, even if the subprograms are not called. Thistest was processed in an environment in which implementor-supplied foreignbodies were present.

AD9004A was graded inapplicable by Evaluaticn Modification as directed bythe AVO. This test uses a single INTERFACE pragma for several overloadedprocedure and function subprograms; this implementation does not supportthe pragma in such circumstances due to the calling conventions of theinterfaced language, and thus rejects the pragma.

CDA201C was graded inapplicable by Evaluation Modification as directed bythe AVO. This test instantiates Unchecked Conversion with an array typewith a non-static index constraint; this implementation does not supportUnchecked Conversion for unconstrained types and so rejects theinstantiation. The AVO ruled that various restrictions onUnchecked Conversion may be accepted for validation under ACVC 1.11,because AI-00590, which addresses Unchecked Conversion, did not show an ARGconsensus at the time of ACVC 1.11's release.

2-5


CE2108B, CE2108D, and CE3112B were graded passed by Test Modification asdirected by the AVO. These tests, respectively, check that temporary filesthat were created by (earlier-processed) CE2108A, CE2108C, and CE3112A arenot accessible after the completion of those tests. However, these testsalso create temporary files. This implementation gives the same names tothe temporary files in both the earlier- and later-processed tests of eachpair; thus, CE2108B, CE2108D, and CE3112B report failed, as though theyhave accessed the earlier-created files. The tests were modified to removethe code that created the (later) temporary file; these modified tests werepassed. Lines 45..64 were conented out in CE2108B and CE2108D; lines40..48 were connented out in CE3112B.

2-6

CHAPTER 3

PROCESSING INFORMATION

3.1 TESTING ENVIRONMENT

The Ada implementation tested in this validation effort is describedadequately by the information given in the initial pages of this report.

For a point of contact for technical information about this Adaimplementation system, see:

Isaac PentinmakiR.R. Software, Inc.P.O. Box 1512Madison, WI 53701

For a point of contact for sales information about this Ada implementationsystem, see:

Jim StewartR.R. Software, Inc.P.O. Box 1512Madison, WI 53701

Testing of this Ada implementation was conducted at the customer's site bya validation team from the AVF.

3.2 Summary Of Test Results

An Ada Implementation passes a given ACVC version if it processes each testof the customized test suite in accordance with the Ada ProgrammingLanguage Standard, whether the test is applicable or inapplicable;otherwise, the Ada Implementation fails the ACVC [Pro90].

3-1


For all processed tests (inapplicable and applicable), a result wasobtained that conforms to the Ada Programming Language Standard.

The list of items below gives the number of ACVC tests in variouscategories. All tests were processed, except those that were withdrawnbecause of test errors (item b; see section 2.1), those that require afloating-point precision that exceeds the implementation's maximumprecision (item e; see section 2.2), and those that depend on the supportof a file system - if none is supported (item d). All tests passed,except those that are listed in sections 2.1 and 2.2 (counted in items band f, below).

a) Total Number of Applicable Tests 3773b) Total Number of Withdrawn Tests 83c) Processed Inapplicable Tests 113d) Non-Processed I/O Tests 0e) Non-Processed Floating-Point

Precision Tests 201

f) Total Number of Inapplicable Tests 314

g) Total Number of Tests for ACVC 1.11 4170

3.3 TEST EXECUTION

The diskettes containing the customized test suite (see section 1.3) weretaken on-site by the validation team for processing. The contents of thediskettes were installed onto a Northgate 386 with DOS 3.30 and thenarchived for installation on the actual host computer. The files wererestored onto a Unisys 386 with SCO Unix.

After the test files were loaded onto the host computer, the full set oftests was processed by the Ada implementation.

The tests were compiled and linked on the host computer system, asappropriate. The executable images were transferred to the target computersystem by the communications link described above, and run. The resultswere captured on the host computer system.

Testing was performed using command scripts provided by the customer andreviewed by the validation team. See Appendix B for a complete listing ofthe processing options for this implementation. It also indicates thedefault options. The options invoked explicitly for validation testingduring this test were:

3-2


The options used for IntegrAda are:

-Q - Quiet error messages - suppresses user prompting on errors.Necessary for running B-Tests; otherwise every error would haveto be responded to.

-W - Warnings off - warnings were suppressed mainly because of themany confusing warnings the validation tests produce. Manyvalidation tests have intentional errors (such as an expressionwhich always raises an exception, use of null ranges, unreachablecode, etc.). The large volume of warnings produced made itdifficult to grade the B-Tests in particular, so they weresuppressed.

-BS - Brief Statistics. This was also used to cut the amount of output

produced by the compiler during compile time.

All other options used their default values.

Then, all of the non-B-Tests were linked with the options:

-Q - Quiet error messages - suppresses user prompting on errors.Necessary for running L-Tests; otherwise every error would haveto be responded to.

-T - Trim unused code - this option directs the linker to removeunused subroutines from the result file. This can make as muchas a 30K space saving in the result file.

-B - Brief Statistics. This was also used to cut the amount of outputproduced by the Linker.

All other options used their default values.

Test output, compiler and linker listings, and job logs were captured onmagnetic tape and archived at the AVF. The listings examined on-site bythe validation team were also archived.

3-3

APPENDIX A

MACRO PARAMETERS

This appendix contains the macro parameters used for customizing the ACVC.The meaning and purpose of these parameters are explained in [UG891. Theparameter values are presented in two tables. The first table lists thevalues that are defined in terms of the maximum input-line length, which isthe value for $MAX IN LEN-also listed here. These values are exp. essedhere as Ada string aggregates, where "V" represents the maximum input-linelength.

Macro Parameter Macro Value

$MAXIN LEN 200

$BIGIDI (I..V-1 -> 'A', V-> '1')

$BIG ID2 (l..V-l -> 'A', V-> '2')

$BIG ID3 (I..V/2 -> 'A') & '3' &(1..V-1-V/2 -> 'A')

SBIGID4 (I..V/2 -> 'A') & '4' &(i..V-1-V/2 -> 'A')

$BIG INT LIT (l..V-3 -> '0') & "298"

$BIG REAL LIT (l..V-5-> '0') & "690.0"

$BIG STRING1 '"' & (l..V/2 -> 'A') & '"'

$BIG STRING2 '"' & (1..V-1-V/2 -> 'A') & '1' & '"'

$BLANKS (1..V-20 -> '

SMAX LEN INT BASED LITERAL"2:" & (l..V-5-> '0') & "11:"

$MAX LEN REAL BASED LITERAL"16:" & (l..V-7-> '0') & "F.E:"

A-1

MACRO PARAMETERS

SMAXSTRINGLITERAL '"' & (l..V-2 -> 'A') & '"'

The following table lists all of the other macro parameters and theirrespective values.

Macro Parameter Macro Value

$ACCSIZE 32

$ALIGNMENT 2

$COUNTLAST 32_767

$DEFAULTMEM_SIZE 65536

$DEFAULTSTORUNIT 8

$DEFAULT SYS-NAME UNIX

$DELTADOC 2#1.0#E-31

$ENTRY ADDRESS (0, 16#40#)

SENTRYADDRESS1 (0, 16#05#)

SENTRY ADDRESS2 (0, 16#01#)

$FIELD LAST 32_767

$FILETERMINATOR ' '

$ FIXEDNAME NOSUCHFIXEDTYPE

$FLOAT NAME NOSUCHFLOAT TYPE

$FORM STRING " "

$FORM STRING2 CANNOT RESTRICT FILECAPACITY

$GREATER THAN-DURATION300_000.0

$GREATERTHANDURATION BASE LASTI.0E6-

$GREATER THAN FLOAT BASE LAST- - l.UE+40

$GREATER THANFLOAT SAFE LARGEl.UE38

A-2

MACROD PAR~AMETERS

$GREATERTHANSHORTFLOAT SAFE LARGE1.07E308-

$HIGHPRIORITY 0

$ILLEGAL EXTERNALFILENAMEl7WDIEC 1ORY/FILENAME

$ ILLEGALEXTERNAL FILE -NAME2

$INAPPROPRIATE-LINELENGTH-1

$INAPPROPRIATEPAGELENGIH-1

$INCLUDEPRAG4A1 PRAG4A INCLUDE ("A28006D1 .ADA")

$INCLUDEPRAQIA.2 PRAGM& INCLUDE ("B28006E1 .ADA")

$INTEGERFIRST -32768

$INTEGERLAST 32767

$INTEGERLASTPLUS_1 32768

$ INTERFACE_-LANGUAGE C

$LESSTHANDURATIN -305 000.0

$LESSTHAN DURATIONBASE FIRST_ -- 17-E6

$LINETERMINATOR ASCII.LF

$LOWPRIORITY 0

$MACHINE-CODE-STATEMENTNULL;

$MACHINECODETYPE NOSUCHTYPE

$MANTISSADOC 31

SMAXDIGITS 15

$MAXINT 2147483647

SMAXINT PLUS 1 2147483648

$MININT -214783648

A-3

MACRO PARAMETERS

$NAME NOSUCHINTEGERTYPE

$NAMELIST UNIX

$NAZIE-SPECIFICATIONi /usr/ike/x2120a

SNANESPECIFICATION2 /usr/ike/x2l20b

$NAMESPECIFICATION3 Aisr/ike/x3119a

$NEGBASEDINT 16*FFFF FFFF#

$NEW YIEM SIZE 65536

$NEWSTORUNIT e$NEWSYSNAME UNIX

$PAGETERMINATOR ASCII.FF

$RECORDDEFINITION RECORD NULL; END RECORD;

$RECORDNAME NOSUCHMACHINECODE TYPE

$TASK-SIZE 32

$TASKSTORAGESIZE 512

$TICK 0.01

$VARIABLEADDRESS FCNDECL.SomeVar 'Address

$VARIABLEADDRESS1 FCNDECL. SomeVar2 'Address

$VARIABLEADDRESS2 FCNDECL.Some Var3'Address

$YOUJR PRAGMA ALLCHECKS

A-4

APPENDIX B

COMPILATION SYSTEM OPTIONS

The compiler options of this Ada implementation are provided by thecustomer and can be found in Appendix F, section F.9, page F-14.

B-i

COMPILATION SYSTEM OPTIONS

LINKER OPTIONS

The linker options of this Ada implementation are provided by the customerand can be found in Appendix F, section F.9, page F-14.

B-2

APPENDIX C

APPENDIX F OF THE Ada STANDARD

The only allowed implementation dependencies correspond toimplementation-dependent pragmas, to certain machine-dependent conventionsas mentioned in Chapter 13 of the Ada Standard, and to certain allowedrestrictions on representation clauses. The implementation-dependentcharacteristics of this Ada implementation, as described in this Appendix,are provided by the customer. Unless specifically noted otherwise,references in this Appendix are to compiler docume-ntation and not to thisreport. Implementation-specific portions of the package STANDARD, whichare not a part of Appendix F, are:

package STANDARD is• ........

type INTEGER is range -32768 .. 32767;

type LONG INTEGER is range -21474838648 .. 2147483647;

type FLOAT is digits 6 range -((2.0 ** 128) - (2.0 ** 104))((2.0 ** 128) - (2.0 ** 104);

type LONGFLOAT is digits 15 range -((2.0 ** 1024) - (2.0 ** 971))((2.0 ** 1024) - (2.0 ** 971));

type DURATION is delta 0.00025 range -((2.0 ** 31) - 1)/4096.0((2.0 ** 31) - 1)/4096.0;

..• ........

end STANDARD;

C-I

Appendix F: Iplementation Deper'dencies

23 Ixnlezentation DependenCies

This- appendix specifies certain system-dependent characteristicsof the IntegrAda, version 5.1.0 386 SCO Unix compiler.

F.1 Implementation Dependent Pragmas

In addition to the required Ada pragmas, IntegrAda also providesseveral others. Some of these pragmas have a textual range. Suchpragmas set some value of importance to the compiler, usually aflag that may be On or Off. The value to be used by the compilerat a given point in a program depends on the parameter of themost recent relevant pragma in the text of the program. Forflags, if the parameter is the identifier On, then the flag ison; if the parameter is the identifier Off, then the flag is off;if no such pragma has occurred, then a default value is used.

The range of a pragma - even a pragma that usually has a textualrange - may vary if the pragma is not inside a compilation unit.This matters only if you put multiple compilation units in afile. The following rules apply:

1) If a pragma is inside a compilation unit, it affectsonly that unit.

2) If a pragma is outside a compilation unit, it affectsall following compilation units in the compilation.

Certain required Ada pragmas, such as INLINE, would followdifferent rules; however, as it turns out, IntegrAda ignores allpragmas that would follow different rules.

The following system-dependent pragmas are defined by IntegrAda.Unless otherwise stated, they may occur anywhere that a pragmamay occur.

ALLCHECKS Takes one of two identifiers On or Off as itsargument, and has a textual range. If the argumentis Off, then this pragma causes suppression ofarithmetic checking (like pragma ARITHCHECK - seebelow), range checking (like pragma RANGECHECK -see below), storage error checking, andelaboration checking. If the argument is On, thenthese checks are all performed as usual. Note thatpragma ALLCHECKS does not affect the status ofthe DEBUG pragma; for the fastest run time code(and the worst run time checking), both ALLCHECKSand DEBUG should be turned Off and the pragmaOPTIMIZE (Time) should be used. Note also thatALLCHECKS does not affect the status of the

F-I

Copyright 1990, R.R. Software, Inc. Revision 4.6

Appendix F: ImpLementation Dependencies

ENUMTAB pragma. Combining check suppression usingthe pragma ALLCHECKS and using the pragmaSUPPRESS may cause unexpected results; it shouldnot be done. However, ALLCHECKS may be combinedwith the IntegrAda pragmas ARITHCHECK andRANGECHECK; whichever relevant pragma has occurredmost recently will determine whether a given checkis performed. ALL CHECKS is on by default. Turningany checks off may cause unpredictable results ifexecution would have caused the correspondingassumption to be violated. Checks should be offonly in fully debugged and tested programs. Afterchecks are turned off, full testing should againbe done, since any program that handles anexception may expect results that will not occurif no checking is done.

ARITHCHECK Takes one of the two identifiers On or Off as itsargument, and has a textual range. WhereARITHCHECK is on, the compiler is permitted to(and generally does) not generate checks forsituations where it is permitted to raiseNUMERICERROR; these checks include overflowchecking and checking for division by zero.Combining check suppression using the pragmaARITHCHECK and using the pragma SUPPRESS may causeunexpected results; it should not be done.However, ARITHCHECK may be combined with theIntegrAda pragma ALL CHECKS; whichever pragma hasoccurred most recently will be effective.ARITHCHECK is on by default. Turning any checksoff may cause unpredictable results if executionwould have caused the corresponding assumption tobe violated. Checks should be off only in fullydebugged and tested programs. After checks areturned off, full testing should again be done,since any program that handles an exception mayexpect results that will not occur if no checkingis done.

CLEANUP Takes an integer literal in the range 0..3 as itsargument, and has a textual range. Using thispragma allows the IntegrAda run-time system to beless than meticulous about recovering temporarymemory space it uses. This pragma can allow forsmaller and faster code, but can be dangerous;certain constructs can cause memory to be used upvery quickly. The smaller the parameter, the moredanger is permitted. A value of 3 -the default

F-2


Appendix F: lmtementation Dependencies

value-causes the run-time system to be its usualimmaculate self. A value of 0 causes noreclamation of temporary space. Values of 1 and 2allow compromising between "cleanliness" andspeed. Using values other than 3 adds some riskof your program running out of memory, especiallyin loops which contain certain constructs.

DEBUG Takes one of the two identifiers On or Off as itsargument, and has a textual range. This pragmacontrols the generation of line number code andprocedure name code. When DEBUG is on, such codeis generated. When DEBUG is off, no line numbercode or procedure names are generated. Thisinformation is used by the walkback which isgenerated after a run-time error (e.g., anunhandled exception). The walkback is stillgenerated when DEBUG is off, but the line numberswill be incorrect, and no subprogram names will beprinted. DEBUG's initial state can be set by thecommand line; if no explicit option is given, thenDEBUG is initially on. Turning DEBUG off savesspace, but causes the loss of much of IntegrAda'spower in describing run time errors.

Notes:DEBUG should only be turned off when the programhas no errors. The information provided on anerror when DEBUG is off is not very useful.

If DEBUG is on at the beginning of a subprogram orpackage specification, then it must be on at theend of the specification. Conversely, if DEBUG isoff at the beginning of such a specification, itmust be off at the end. If you want DEBUG to beoff for an entire compilation, then you can eitherput a DEBUG pragma in the context clause of thecompilation or you can use the appropriatecompiler option.

ENUMTAB Takes one of the two identifiers On or Off as itsargument, and has a textual range. This pragmacontrols the generation of enumeration tables.Enumeration tables are used for the attributesIMAGE, VALUE, and WIDTH, and hence to input andoutput enumeration values. The tables aregenerated when ENUMTAB is on. The state of theENUMTAB flag is significant only at enumerationtype definitions. If this pragma is used to

F-3


Appendix F: impLementation Dependencies

prevent generation of a type's enumeration tables,then using the three mentioned attributes causesan erroneous program, with unpredictable results;furthermore, the type should not be used as ageneric actual discrete type, and in particularTEXT IO.ENUMERATION 10 should not be instantiatedfor the type. If the enumeration type is notneeded for any of these purposes, the tables,which use a lot of space, are unnecessary. ENUMTABis on by default.

PAGELENGTH This pragma takes a single integer literal as itsargument. It says that a page break should beadded to the listing after each occurrence of thegiven number of lines. The default page length is32000, so that no page breaks are generated formost programs. Each page starts with a header thatlooks like the following:

IntegrAda Version 5.1.0 compiling file on date at time

RANGECHECK Takes one of the two identifiers On or Off as itsargument, and has a textual range. WhereRANGECHECK is off, the compiler is permitted to(and generally does) not generate checks forsituations where it is expected to raiseCONSTRAINT ERROR; these checks include nullpointer checking, discriminant checking, indexchecking, array length checking, and rangechecking. Combining check suppression using thepragma RANGECHECK and using the pragma SUPPRESSmay cause unexpected results; it should not bedone. However, RANGECHECK may be combined with theIntegrAda pragma ALL CHECKS; whichever pragma hasoccurred most recently will be effective.RANGECHECK is on by default. Turning any checksoff may cause unpredictable results if executionwould have caused the corresponding assumption tobe violated. Checks should be off only in fullydebugged and tested programs. After checks areturned off, full testing should again be done,since any program that handles an exception mayexpect results that will not occur if no checkingis done.

OPTIMIZER Takes one of the identifiers On or Off, or aninteger literal, as an argument. This pragmaturns optimization on or off, either totally orpartially. It has a textual range, except that if

F-4


Appendix F: Implementation Dependencies

the global optimizer is turned on for any part ofa compilation unit, then it is on for the entirecompilation unit. If the identifier is On or Off,then IntegrAda's optimizers are turned totally onor totally off, as appropriate. An integerliteral as an arguement causes optimization to beturned partially on or off.

The following integer literals are meaningful asan argument to this pragma:

1) Turns check elimination optimizations on.2) Turns the basic block optimizer on.3) Turns the global optimizer on. If this is on

anywhere in a compilation unit, it will be oneverywhere in that unit.

4) Turns peephole optimizations on.5) Puts the optimizer in 'Space' optimization

mode (the default).6) Puts the optimizer in 'Careful' optimization

mode. The can take much longer than 'Quick'optimization, but will find moreoptimizations.

7) Puts the compiler in 'Fastest alignment'mode. Data objects will be aligned for thefastest performance on the target (unlessoverridden by rep. clauses). This takes moredata space.

51) Turns check elimination optimizations off.Useful for finding uninitialized variables.

52) Turns the basic block optimizer off.53) Turns the global optimizer off.54) Turns peephole optimizations off.55) Puts the optimizer in 'Time' optimization

mode.56) Puts the optimizer in 'Quick' optimization

mode. This is faster than 'Careful'optimizations, and often will generate nearlythe same code.

57) Put the compiler in 'Smallest alignment'mode. Data is only aligned when required orwhen the performance penalty is severe.Takes less data space.

Other integer literals will be ignored. Ingeneral, this pragma should not be mixed with theOPTIMIZE praama, since one has a textual arangeand the other does not; this can lead tosurprising situations. However, the OPTIMIZE

F-5


Appenix F: ImpLementation Dependencies

pragma may be used inside a compilation unit forwhich pragma OPTIMIZER(On) has been listed beforethe start of the compilation unit.

SYSLIB This pragma tells the compiler that the currentunit is one of the standard IntegrAda systemlibraries. It takes as a parameter an integerliteral in the range 1 .. 15; only the values 1through 4 are currently used. For example, systemlibrary number 2 provides floating point support.Do not use this pragma unless you are writing apackage to replace one of the standard IntegrAdasystem libraries.

VERBOSE Takes On or Off as its argument, and has a textualrange. VERBOSE controls the amount of output on anerror. If VERBOSE is on, the two lines precedingthe error are printed, with an arrow pointing atthe error. If VERBOSE is off, only the line numberis printed.

VERBOSE(Off):

Line 16 at Position 5*ERROR* Identifier is not defined

VERBOSE (On):

15: if X 1 10 then16: Z := 10;

*ERROR* Identifier is not defined

The reason for this option is that an errormessage with VERBOSE on can take a long time to begenerated, especially in a large program.VERBOSE's initial condition can be set by thecompiler command line.

Pragma INTERFACE is supported for the language "C". PragmaINTERFACE NAME can be used to specify a name other than the Adaone as the name of the C function called. INTERFACE NAME takestwo parameters, the Ada subprogram name, and a stringrepresenting the C name for the function. Pragma INTERFACENAMEis provided so that convienient Ada names can be used asappropriate, including operator symbols, and so that foreignlanguage names which are not legl Ada identifiers can beinterfaced to. If pragma INTERFACE is used in a program,

F-6


Appendix F: laplementation Dependencies

Jbind must be used to link it, and it must be linked with theInterface run-time.

Several required Ada pragmas may have surprising effects inIntegrAda. The PRIORITY pragma may only take the value 0, sincethat is the only value in the range System.Priority. Specifyingany OPTIMIZE pragma turns on optimization; otherwise,optimization is only done if specified on the compiler's commandline. The F:UPPRESS pragma is ignored unless it only has oneparameter. Also, the following pragmas are always ignored:CONTROLLED, INLINE, MEMORYSIZE, PACK, SHARED, STORAGE UNIT, andSYSTEM NAME. Pragma CONTROLLED is always ignored becauseIntegrAda does no automatic garbage collection; thus, the effectof pragma CONTROLLED already applies to all access types. PragmaSHARED is similarly ignored: IntegrAda's non-preemptive taskscheduling gives the appropriate effect to all variables. Thepragmas INLINE, PACK, and SUPPRESS (with two parameters) allprovide recommendations to the compiler; as Ada allows, therecommendations are ignored. The pragmas MEMORY SIZE,STORAGEUNIT, and SYSTEM NAME all attempt to make changes toconstants in the System package; in each case, IntegrAda allowsonly one value, so that the pragma is ignored.

F.2 Implesentation Dependent Attributes

IntegrAda does not provide any attributes other than the requiredAda attributes.

F.3 Specification of the Package SYSTEM

The package System for IntegrAda has the following definition.

package System is

-- System package for IntegrAda

-- Types to define type Address.type Offset Type is new LongInteger;tye. Word is range 0 .. 65536;for Word'Size use 16;type Address is record

Offset : Offset Type;Segment : Word;

end record;Function "+" (Left : Address; Right : OffsetType) Return

Address;Function "+" (Left : OffsetType; Right : Address) Return

Address;Function "-" (Left : Address; Right : OffsetType) Return

F-7


Appendix F: Imltementation Dependencies

Address;Function "-" (Left, Right : Address) Return Offset_Type;

type Name is (UNIX);

SystemName : constant Name := UNIX;

Storage Unit : constant := 8;MemorySize : constant := 65536;

-- Note: The actual memory size of a program is-- determined dynamically; this is the maximum number-- of bytes in the data segment.

-- System Dependent Named Numbers:Min Int : constant := -2 147 483 648;Max-Int : constant .= 2_147_483_647;MaxDigits : constant :=-15;-Max Mantissa : constant := 31;Fine Delta : constant := 2#1.0#E-31;

-- equivalently, 4.656612873077392578125E-10Tick : constant := 0.01; -- Some machines have less

-- accuracy; for example, the IBM PC actually ticks-- about every 0.06 seconds.

-- Other System Dependent Declarationssubtype Priority is Integer range 0..0;

type Byte is range 0 .. 255;

for Byte'Size use 8;

end System;

The type Byte in the System package corresponds to the 8-bitmachine byte. The type Word is a 16-bit Unsigned Integer type,corresponding to a machine word.

7.4 Restrictions on Representation Clauses

A length clause that specifies T'SIZE has the followingrestrictions:

If T is a discrete type, or a fixed point type, then thesize expression can given any value between 1 and 32 bits(subject, of course, to allowing enough bits for everypossible value). Signed and unsigned representations aresupported.


Appendix F: Impeamntation Dependencies

If T is a floating point type, sizes of 32 and 64 bits aresupported (corresponding to Float and LongFloatrespectively).

If T is an array or record type, the expression must giveenough room to represent all of the components of the typein their object representation. This can be smaller thanthe default size of the type.

If T is an access type or task type, the expression mustgive the default size for T.

A length clause that specifies T'STORAGESIZE for an access typeis supported.

Any integer value can be specified. STORAGEERROR will be raisedif the value is larger than available memory; no space will beallocated if the value is less than or equal to zero.

A length clause that specifies T'STORAGESIZE for a task type Tis supported. Any integer value can be specified. Valuessmaller than 256 will be rounded up to 256 (the minimumT'StorageSize), as the Ada standard does not allow raising anexception in this case.

A length clause that specifies T'SMALL for a fixed point type

must give a value (subject to the Ada restrictions) in the range

2.0 ** (-99) .. 2.0 ** 99,

inclusive.

An enumeration representation clause for a type T may give anyinteger values within the range System.Min Int .. System.Max Int.If a size length clause is not given for the type, the type'ssize is determined from the literals given. (If all of theliterals fit in a byte, then Byte'Size is used; similarly forInteger and Long-Integer).

The expression in an alignment clause in a record representationclause must equal 1 or 2 (to specify Byte or Word alignmentrespectively). The alignment value is respected for all objectcreations unless another representation clause explicitlyoverrides it. (By placing a component at a non-aligned address,for example).

A component clause may give any desired storage location. Thesize of the record is adjusted upward if no representation clause

F-9


Appendix F: imptementation Dependencies

has been given, and more space is needed for the specifiedstorage location to be obeyed.

The range for specifying the bits may specify any values withinthe following limitations (assuming enough bits are allowed forany value of the subtype):

If the component type is a discrete or fixed point type, anyvalue may be specified for the lower bound. The upper boundmust satisfy the equation

UB - (LB - (LB Mod System.STORAGEUNITSIZE)) <= 32.

If the component type is any other type, the lower boundmust satisfy

LB Mod System.STORAGEUNITSIZE = 0.

The upper bound must be

UB := LB + T'Size - 1;

IntegrAda supports address clauses on most objects. Addressclauses are not allowed on parameters, generic formal parameters,and renamed objects. The address given for an object addressclause may be any legal value of type System.Address. It will beinterpreted as an absolute machine address, using the segmentpart as a selector if in the protected mode. It is the user'sresponsibility to ensure that the value given makes sense (i.e.,points at memory, does not overlay other objects, etc.) No otheraddress clauses are supported.

P.5 Implementation Defined Names

IntegrAda uses no implementation generated names.

1.6 Address Clause Expressions

The address given for an object address clause may be any legalvalue of type System.Address. It will be interpreted as anabsolute machine address, using the segment part as a selector ifin the protected mode. It is the user's responsibility to ensurethat the value given makes sense (i.e., points at memory, doesnot overlay other objects, etc.)

1.7 UncheckedConversion Restrictions

We first make the following definitions:

F-10


AIppeix F: pl emmt ttion Depoenencies

A type or subtype is said to be a simple type or a simple subtype(respectively) if it is a scalar (sub)type, an access (sub)type,a task (sub)type, or if it satisfies the following twoconditions:

1) If it is an array type or subtype, then it isconstrained and its index constraint is static; and

2) If it is a composite type or subtype, then all of itssubcomponents have a simple subtype.

A (sub)type which does not meet these conditions is called non-simple. Discriminated records can be simple; variant records canbe simple. However, constraints which depend on discriminantsare non-simple (because they are non-static).

IntegrAda imposes the following restriction on instantiations ofUncheckedConversion: for such an instantiation to be legal, boththe source actual subtype and the target actual subtype must besimple subtypes, and they must have the same size.

F.8 Iplientation Dependencies of I/O

The syntax of an external file name depends on the operatingsystem being used. Some external files do not really specify diskfiles; these are called devices. Devices are specified by specialfile names, and are treated specially by some of the I/Oroutines.

The syntax of an UNIX filename is:

(path]filename

where "path" is an optional path consisting of directorynames, each followed by a foreslash; "filename" is thefilename (maximum 14 characters). See your UNIX manual for acomplete description. In addition, the following specialdevice names are recognized:

/dev/sti UNIX standard input. The same asStandard-Input. Input is buffered by lines,and all UNIX line editing characters may beused. Can only be read.

/dev/sto UNIX standard output. The same asStandard Output. Can only be written.

/dev/err UNIX standard error. The output to thisdevice cannot be redirected. Can only bewritten.

/dev/ekbd The current terminal input device. Singlecharacter input with echoing. Due to the

F-11

Copyright 1990, R.R. Software, Inc. Pevisior 4.6

Appendix F: ImpLementation Dependencies

design of UNIX, this device can beredirected. Can be read and written.

/dev/kbd The current terminal input device. Nocharacter interpretation is performed, andthere is no character echo. Again, the inputto this device can be redirected, so it doesnot always refer to the physical keyboard.

The UNIX device files may also be used.

The UNIX I/O system will do a search of the default searchpath (set by the environment PATH variable) if the followingconditions are met:

1) No path is present in the file name; and

2) The name is not that of a device.

Alternatively, you may think of the search being done if thefile name does not contain any of the characters ':' or '/'.

The default search path cannot be changed while the programis running, as the path is copied by the IntegrAda programwhen it starts running.

Note:Creates will never cause a path search as they must work inthe current directory.

Upon normal completion of a program, any open external files areclosed. Nevertheless, to provide portability, we recommendexplicitly closing any files that are used.

Sharing external files between multiple file objects causes thecorresponding external file to be opened multiple times by theoperating system. The effects of this are defined by youroperating system. This external file sharing is only allowed ifall internal files associated with a single external file areopened only for reading (mode In_File), and no internal file isCreated. Use Error is raised if these requirements are violated.A Reset to a writing mode of a file already opened for readingalso raise Use Error if the external file also is shared byanother internal file.

Binary I/O of values of access types will give meaninglessresults and should not be done. Binary I/O of types which arenot simple types (see definition in Section F.7, above) willraise Use_Error when the file is opened. Such types require

F-12


Appendix F: iuptementation Dependencies

specification of the ilock size in the form, a capability whichis not yet supported.

The form parameter for SequentialIO and DirectIO is alwaysexpected to be the null string.

The type Count in the generic package DirectIO is defined tohave the range 0 .. 2_147_483_647.

Ada specifies the existence of special markers called terminatorsin a text file. IntegrAda defines the line terminator to be <LF>(line feed), with or without an additional <CR> (carriagereturn). The page terminator is the <FF> (form feed) character;if it is not preceded by a <LF>, a line terminator is alsoassumed.

The file terminator is the end-of-file returned by the hostoperating system. If no line and/or page terminator directlyprecedes the file terminator, they are assumed. The only legalform for text files is "" (the null string). All other formsraise USEERROR.

Output of control characters does not affect the layout thatText 10 generates. In particular, output of a <LF> before aNewPage does not suppress the NewLine caused by the New-Page.

The character <LF> is written to represent the line terminator.

The type Text_IO.Count has the range 0 .. 32767; the typeTextIO.Field also has the range 0 .. 32767.

IOExceptions.USEERROR is raised if something cannot be donebecause of the external file system; such situations arise whenone attempts:

- to create or open an external file for writing when theexternal file is already open (via a different internalfile).

- to create or open an external file when the externalfile is already open for writing (via a differentinternal file).

- to reset a file to a writing mode when the externalfile is already open (via a different internal file).

- to write to a full device (Write, Close);- to create a file in a full directory (Create);- to have more files open than the OS allows (Open,

Create);- to open a device with an illegal mode;- to create, reset, or delete a device;

F-13


Appendix F: lmplementation Dependencies

to create a file where a protected file (i.e., adirectory or read-only file) already exists;

- to delete a protected file;- to use an illegal form (Open, Create); or- to open a file for a non-simple type without specifying

the block size;to open a device for direct I/O.

IOExceptions.DEVICE ERROR is raised if a hardware error otherthan those covered by USEERROR occurs. These situations shouldnever occur, but may on rare occasions. For example, DEVICEERRORis raised when:

- a file is not found in a Close or a Delete;- a seek error occurs on a direct Read or Write; or- a seek error occurs on a sequential EndOfFile.

The subtypes Standard.Positive and Standard.Natural, used by someI/O routines, have the maximum value 32767.

No package LowLevelIO is provided.

P.9 Running the compiler and linker

The IntegrAda compiler is invoked using the following format:

iada filename (-option)

where filename is an UNIX file name (including path) withoptional compiler options (-option).

The compiler options are:

B Brief error messages. The line in error is not printed(equivalent to turning off pragma VERBOSE).

BS Brief statistics. Few compiler statistics are printed.

D Don't generate debugging code (equivalent to turningoff pragma DEBUG)

F Use in-line 80387 instructions for Floating pointoperations. By default the compiler generates librarycalls for floating point operations. The 80387 may beused to execute the library calls. A floating pointsupport library is still required, even though thisoption is used.

F-14


Appendix F: Imptementation Dependencies

L Create a listing file with name filename.PRN on thesame disk as filename. The listing file will be alisting of only the last compilation unit in a file.

Ox Object code memory model. X is 0 for the 80386 system.Other memory models are not supported. (Since thismodel 'limits' a program to 4 Gigabytes of Code and 4Gigabytas of Data, this is not a concern). Memorymodel 0 is assumed if this option is not given.

Q Quiet error messages. This option causes the compilernot to wait for the user to interact after an error. Inthe usual mode, the compiler will prompt the user aftereach error to ask if the compilation should be aborted.This option is useful if the user wants to take acoffee break while the compiler is working, since alluser prompts are suppressed. The errors (if any) willnot stay on the screen when this option is used;therefore, the console traffic should be sent to theprinter or to a file. Be warned that certain syntaxerrors can cause the compiler to print many errormessages for each and every line in the program.

Rpath Route the SYM, SRL, and JRL files produced by thecompiler to the specified path 'path'. The default isthe same path as filename.

Spath Route Scratch files to specified path.

T Generate information which allows trimming unusedsubprograms from the code. This option tells thecompiler to generate information which can be used bythe remove subprograms from the final code. Thisoption increases the size of the .JRL files produced.We recommend that it be used on reusable libraries ofcode (like trig. libraries or stack packages) - that isthose compilations for which it is likely that somesubprograms are not called.

W Don't print any warning messages. For more control ofwarning messages, use the following option form (Wx).

Wx Print only warnings of level less than the specifieddigit 'x'. The given value of x may be from 1 to 9. Themore warnings you are willing to see, the higher thenumber you should give.

X Handle eXtra symbol table information. This is for theuse of debuggers and other future tools. This option

F-15


Appendix F: Imptemntoion Dependencies

requires large quantities of memory and disk space, andthus should be avoided if possible.

Z Turn on optimization. This has the same effect as ifthe pragma OPTIMIZE were set to SPACE throughout yourcompilation.

The default values for the command line options are:

B Error messages are verbose.BS Statistics are verbose.D Debug code is generated.F Library calls are generated for floating point operations.L No listing file is generated.0 Memory model 0 is used.Q The compiler prompts for abort after every error.T No trimming code is produced.W All warnings are printed.X Extra symbol table information is not generated.Z Optimization is done only where so specified by pragmas.

Leading spaces are disregarded between the filename and the callto Iada. Spaces are otherwise not recommended on the commandline. The presence of blanks to separate the options will beignored.

Examples:iada test-Q-Liada test.run-W4iada testiada test .run -B -W-L

The compiler produces a SYM (SYMbol table information) file whena specification is compiled, and a SRL or JRL (SpecificationReLocatable or Janus ReLocatable) file when a body is compiled.To make an executable program, the appropriate SRL and JRL filesmust be linked (combined) with the run-time libraries. This isaccomplished by running IntegrAda binder, JBIND.

The IntegrAda binder is invoked using the following format:

jbind filename (-option)

Here "filename" is the name of the SRL or JRL file created whenthe main program was compiled (without the .SRL or .JRLextension) with optional linker options (-option). The filenameusually corresponds to the first ten letters of the name of yourmain program. See the linker/binder manual for more detailed

F-16


Appendix F: implemntation Dependencies

directions. We summarize here, however, a few of the mostcommonly used linking options:

FO Use software floating point (the default).F2 Use hardware (80387) floating point.L Display lots of information about the loading process.00 Use memory model 0 (the default); see the description of the

/0 option in the compiler, above.Q Use quiet error messages; i.e., don't wait for the user to

interact after an error.B Use brief statistics.T Trim unused subprograms from the code. This option tells

the linker to remove subprograms which are never called fromthe final output file. This option reduc-s space usage ofthe final file by as much as 30K.

Examples:jbind testjbind test -Q-Ljbind test-L-F2

Note that if you do not have a hardware floating point chip, thenyou generally will not need to use any binder options.

The output of Jbind is a standard UNIX .o file. This file mustbe linked with the standard UNIX libraries using ld; see yourUNIX manual for details.

F-17


Documents

IFinal - DTICLogin · Maaquafls mi Su. D y, Su" 1204, A*ron, VA 22202-=302 end to dt. office di f ibmu SM R.pAWWy AI.., 01rc di 1. AGENCY USE ONLY (Leave Blank) 12. REPORT IFinal: