R 11 jjjjjjj'ljlll jjll 348 j1 11i1111' 'lIi N PAGE F ... AD-A260 11 jjjjjjj'ljlll jjll 348j1...

AD-A260 348R 11 jjjjjjj'ljlll jjll j1 11i1111' 'lIi N PAGE F ormApov.,ed

NAM~i reportiq; burden 11 1 111 11 Pof.=lom( 0Iooded. and mý ikxig fth firmg for rOv~lftn0 pnerctone, swIchmg OXiltrig data sw e gathern and mucunin t4-al

Head KI. a ier wvm , i ar y other U P eC of this cob icw n of ilorm oion, anc ludV ng b 1,g~ t r fo d rC in this burden. to W ashing ton

Ma aea l lrnem a end k• Bu gw ut j AY. Sukel 1204 .A ,"lr on. VA 22202-4302. and lo the CM " : of Ird aor lln endl paog atory Affaws, Office ofMaaemn and Bug,. .... , u, ,. u,. *- =.

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

I Final: 15 Dec 924. TITLE AND SUBTITLE 5. FUNDING NUMBERS

Validation Summary Report: Software Leverage, Inc., Stratus Ada, Version 6.1,XA/R20 under FTX, 2.0.1 (Host & Target), 921015W1.11294

6 AUTHOR(S)

Wright-Patterson AFB, Dayton, OHUSA

7. PERFORMING ORGANIZATION NAME(S) AND ADDRESS(ES) 8. PERFORMING ORGANIZATION

Ada Validation Facility, Language Control Facility ASD/SCEL REPORT NUMBER

Bldg. 676, Rm 135 AVF-VSR-557.1092Wright-Patterson AFB, Dayton, OH 45433

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

Ada Joint Program Office REPORT NUMBER

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

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

Approved for public release; distribution unlimited.

13. ABSTRACT (Maximum 200 words)

Software Leverage, Inc., Stratus Ada, Version 6.1, XA/R20 under FTX, 2.0.1 (Host & Target), ACVC 1.11.

QTg

14, SUBJECT TERMS '/./" R PAE

Ada programming language, Ada Compiler Val. Summary Report, Ada Compiler Val.

Capability, Val. Testing, Ada Val. Office, Ada Val. Facility, ANSI/MIL-STD-1815A, AJPO. 16. PRICE CODE

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

UNCLASSIFIED UNCLASSIFED UNCLASSIFIEDNSN 7540-01-280-550 Standard Form 298, (Rev. 2-89)

Prescribed by ANSI Std. 239-128

AVF Control Number: AVF-VSR-557.1092Date VSR Completed: 15 December 1992

92-07--09-SWL

Ada COMPILERVALIDATION SUMM'tARY REPORT:

Certificate Number: 921015W1.11294Software Leverage, Inc.

Stratus Ada, Version 6.1XA/R20 under FIX, 2.0.1

(FINAL)

Prepared By:Ada validation Facility

645 C-CSG/SCSLWright-Patterson AFB OH 45433-6503

93-01447

Certificate Information

The following Ada implementation was tested and determined to pass ACVC1.11. Testing was completed on 15 October 1992.

Compiler Name and Version: Stratus Ada, Version 6.1

Host Computer System: XA/R20under FTX, 2.0.1

Target Computer System: XA/R20under FTX, 2.0.1

Customer Agreement Number: 92-07-09-SWL

See section 3.1 for any additional information about the testingenvironment.

As a result of this validation effort, Validation Certificate921015WI.11294 is awarded to Software Leverage, Inc. This certificateexpires two years after the ANSI adoption of ANSI/MIL-STD-1815B.

This report has been reviewed and is approved.

Ada Validaton FacilitySteven P. WilsonTechnical Director645 C-CSG/SCSLWright-Patterson AFB OH 45433-6503

Aa ydtion Organization��Dire to omputer and Software Engineering Division

Institute Tor Defense AnalysesAlexandria VA 22311

Aession Fol r

GTI GA&I

DTIC TAB0Uuarý=ooed

Ada oint Program Office Jus c fication--.--

Dr. John Solomond, DirectorDepartment of DefenseWashington DC 20301 DIiosrlbU lah..........

Availability Codesveall anid/or

Ma I aa

DECLARATION OF CONFORMANCE

The following declaration of conformance was supplied by the customer.

Declaration of Conformance

Customer: Software Leverage, Inc.

Certificate Awardee: Stratus Computer, Inc.

Ada Validation Facility: ASC/SCEL, Wright-Patterson AFB OH 45433-6503

ACVC Version: 1.11

Ada Implementation:

Ada Compiler Name and Version: Stratus Ada, Version 6.1

Host Computer System: XA/R20under FTX, 2.0.1

Target Computer System: XA/R20under FTX, 2.0.1

Declaration:

We, the undersigned, declare that we have noknowledge of deliberate deviations from the Ada LanguageStandar SI/M STD-1851A ISO 8652-1987 in the implementationliste ve.

Customer Signature Date

Certificate Awardee Signature Date

TABLE OF CONTENTS

CHAPTER 1 INTRODUCTION

1.1 USE OF THIS VALIDATION SUMMARY REPORT .... ...... 1-i1.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 SUMMARY OF TEST RESULTS ....... ............. .. 3-23.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[Prog90. 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 OrganizationComputer and Software Engineering DivisionInstitute for Defense Analyses1801 North Beauregard StreetAlexandria VA 22311-1772

1-1

INTRODUCTION

1.2 REFERENCES

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

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

(UG891 Ada Compiler Validation Capability User's Guide, 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 class towhich it belongs. Class A, C, D, and E tests are executable. Class B andclass L tests are expected to produce errors at compile time and link time,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 SPPRTI3,and the procedure CHECK FILE are used for this purpose. The package REPORTalso provides a set of Tdentity 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 operating 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), andpossibly removing 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 suite 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 computzr 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 2 August 1991.

E28005C B28006C C32203A C34006D C355081 C35508JC35508M C35508N C35702A C35702B B41308B C43004AC45114A C45346A C45612A C45612B C45612C C45651AC46022A B49008A B49008B A74006A C74308A B83022BB83022H B83025B B83025D C83026A B83026B C83041AB85001L C86001F C94021A C97116A C98003B BA2011ACB7001A CB7001B CB7004A CC1223A BC1226A CC1226BBC3009B BDlB02B BD1B06A AD1B08A BD2AO2A CD2A21ECD2A23F CD2A32A CD2A41A CD2A4lE CD2A87A CD2Bl5CBD3006A BD4008A CD4022A CD4022D CD4024B CD4024CCD4024D CD4031A CD4051D CD5111A CD7004C ED7005DCD7005E AD7006A CD7006E AD7201A AD7201E CD7204BAD7206A 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 the ISO and the AJPO known as AdaCommentaries and conmmonly 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

IMPLEMENTION D_ -4D4ENCIES

The following 201 tests have floating-point type declarationsrequiring more 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 20 tests check for the predefined type LONGINTEGER; forthis implementation, there is no such type:

C35404C C45231C C45304C C45411C C45412CC45502C C45503C C45504C C45504F C45611CC45613C C45614C C45631C C45632C B52004DC55B07A B55B09C B86001W C86006C CD7101F

C35713C, B86001U, and C86006G check for the predefined typeLONG FLOAT; for this implementation, there is no such type.

C35713D and B86001Z check for a predefined floating-point type with aname other than FLOAT, LONG FLOAT, or SHORT FLOAT; for thisimplementation, there is no such type.

A35801E checks that FLOAT'FIRST. .FLOAT'LAST may be used as a rangeconstraint in a floating-point type declaration; for thisimplementation, that range exceeds the range of safe numbers of thelargest predefined floating-point type and must be rejected. (Seesection 2.3.)

C45531M..P and C45532M..P (8 tests) check fixed-point operations fortypes that require a SYSTEM.MAX MANTISSA of 47 or greater; for thisimplementation, MAXMANTISSA is less than 47.

C45624A..B (2 tests) check that the proper exception is raised ifMACHINE OVERFLOWS is FALSE for floating point types and the results ofvarious floating-point operations lie outside the range of the basetype; for this implementation, MACHINEOVERFLOWS is TRUE.

B86001Y uses the name of a predefined fixed-point type other than typeDURATION; for this implementation, there is no such type.

C96005B uses values of type DURATION's base type that are outside therange of type DURATION; for this implementation, the ranges are thesame.

CD1009C checks whether a length clause can specify a non-default sizefor a floating-point type; this implementation does not support suchsizes.

2-2


CD2A84A, CD2A84E, CD2A84I..J (2 tests), and CD2A840 use length clausesto specify non-default sizes for access types; this implementationdoes not support such sizes.

The tests listed in the following table check that USE ERROR is raisedif the given file operations are not supported for the givencombination of mode and access method; this implementation supportsthese operations.

Test File Operation Mode File Access Method

CE2102D CREATE IN FILE SEQUENTIAL 10CE2102E CREATE OrT FILE SEQUENTIAL0IOCE2102F CREATE INOUT FILE DIRECT 10CE2102I CREATE IN FILE DIRECT-IOCE2102J CREATE OUT FILE DIRECT-IOCE2102N OPEN IN FILE SEQUENTIAL 10CE21020 RESET IW-FILE SEQUENTIAL0IOCE2102P OPEN OUT FILE SEQUENTIAL0IOCE2102Q RESET OUT-FILE SEQUENTIAL0IOCE2102R OPEN INOUT FILE DIRECT 10CE2102S RESET INOUT_-FILE DIRECT-IOCE2102T OPEN IN FILE DIRECT-IOCE2102U RESET IN -FILE DIRECT-IOCE2102V OPEN OUT FILE DIRECT-I0CE2102W RESET OUT -FILE DIRECT-10CE3102E CREATE IN FILE TEXT 15CE3102F RESET Any Mode TEXT1--CE3102G DELETE TEXT-IOCE3102I CREATE OUT FILE TEXT IOCE3102J OPEN IN FILE TXT--10CE3102K OPEN OUT FILE TEXT-IO.

CE2203A checks that WRITE raises USE ERROR if the capacity of anexternal sequential file is exceeded; this implementation cannotrestrict file capacity.

CE2403A checks that WRITE raises USE ERROR if the capacity of anexternal direct file is exceeded; this implementation cannot restrictfile capacity.

CE3304A checks that SET LINE LENGTH and SET PAGE LENGTH raiseUSE ERROR if they s•ecify an inappropriate value fo? the externalfile; there are no inappropriate values for this implementation.

CE3413B checks that PAGE raises LAYOUT ERROR when the value of thepage number exceeds COUNT'LAST; for this Implementation, the value ofCOUNT'LAST is greater than 150000, making the checking of thisobjective impractical.

2-3


2.3 TEST MODIFICATIONS

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

The following tests were split into two or more tests because thisimplementation did not report the violations of the Ada Standard in theway expected by the original tests.

B24009A B33301B B38003A B38003B B38009A B38009BB85008G B85008H BC1303F BC3005B BD2BO3A BD2DO3AB&4003A

A35801E was graded inapplicable by Evaluation Modification as directed bythe AVO. The compiler rejects the use of the rangeFLOAT'FIRST..FLOAT'LAST as the range constraint of a floating-point typedeclaration because the bounds lie outside of the range of safe numbers(cf. LRM 3.5.7:12).

2-4

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 technical information about this Ada implementation, contact:

Daniel GrosshansSoftware Leverage, Inc.485 Massachusetts Ave.Arlington, MA 02174-5103(617) 648-1414

For sales information about this Ada implementation, contact:

Lisa LudwigStratus Computer, Inc.55 Fairbanks Blvd.Marlboro, MA 01752-1298(508) 460-2695

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

3-1


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 ProgramningLanguage Standard, whether the test is applicable or inapplicable;otherwise, the Ada Implementation fails the ACVC [Pro90].

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 3805b) Total Number of Withdrawn Tests 95c) Processed Inapplicable Tests 69d) Non-Processed I/O Tests 0e) Non-Processed Floating-Point

Precision Tests 201

f) Total Number of Inapplicable Tests 270 (c+d+e)

g) Total Number of Tests for ACVC 1.11 4170 (a+b+f)

3.3 TEST EXECUTION

A magnetic tape containing the customized test suite (see section 1.3) wastaken on-site by the validation team for processing. The contents of themagnetic tape were loaded directly onto the host computer.

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:

OPTIONS Effect

-el Intersperse error messages among source

3-2


lines and direct to standard output.

-M unit name Produce an executable program by linkingthe named unit as the main program.

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 SMAX IN LEN-also listed here. These values are expressedhere as Ada string aggregates, where "V'" represents the maximum input-linelength.

Macro Parameter Macro Value

$MAX IN LEN 499 - Value of V

$BIG IDI (l..V-i => 'A', V => '1')

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

$BIG ID3 (l..V/2 W> 'A') & '3' &(l..V-l-V/2 -> 'A')

$BIGID4 (l..V/2 -> 'A') & '4' &(l..V-1-V/2 => 'A')

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

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

SBIGSTRING1 '"' & (I..V/2 -> 'A') & '"'

$BIGSTRING2 '"' & (1..V-I-V/2 => 'A') & 'I' & '"'

SBLANKS (i..V-20 => '

SMAXLENqINTBASED LITERAL"2:" & (1..V-5 => '0') & "I1:"

SMAX LE- REAL BASED LITERAL"16:" & (1..V-7 -> '0') & "F.E:"

A-i

MACRO PARAMETERS

$MAXSTRINGLITERAL ' & (1..V-2 -> WA) &''

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

Macro Parameter Macro Value

$ACC-SIZE 32

$ALIGNMENT 8

$COUNTLAST 2_147_483_647

$DEFAULTMEMSIZE 16_777_216

$DEFAULT STOR UNIT 8

$DEFAULTSYSNAME I860_SYSTEMV

$DELTADOC 0. 000000000465612873077392578125

$ENTRY ADDRESS SYSTEM."+"(2)

$ENTRYADDRESS1 SYSTEM."(3

$ENTRYADDRESS2 SYSTEM."+"(18)

$FIELDLAST 2_147_483_647

$FILE TERMINATOR I '

$FIXEDNAME NOSUCHTYPE

$ FLOATNAME NOSUCH TYPE

$FORMSTRING f'il

$ FORMSTRING2 "CANNOTRESTRICT FILE CAPACITY

$GREATERTHANDURATION 100.

$GREATERTHAN DURATION BASE LAST-10_006_000.0

$GREATERTHANFLOAT BASE LAST_ - 1.'E+308

$GREATERTHAN FLOAT SAFE LARGE5.XE3O7

MACRO PARAMETERS

$GREATER THAN SHORT FLOAT SAFE LARGE9.07E37

$HIGHPRIORITfl 99

$ILLEGA.LEXTERNALFILE NAME17illegal/file-nazn/21 ]%2102c.dat"

$ ILLEGALEXTERNALFILE NAME27illegal/file-name/CE2102C* .dat"

$ INAPPROPRIATELINELENGTH-1

$ INAPPROPRIATEPAGELENGTH-1

$INCLUDEPRAGMAl PRAGMA INCLUDE ("A28006D1.TST"l)

$INCLUDEPRAG4A.2 PRAGIIA INCLUDE ("B28006D1.TST")

$INTEGERFIRST -2147483648

$INTEGER-LAST 2147483647

$INTEGERLASTPLUS_1 2147483647

$ INTERFACELANGUAGE C

$LESSTHAN-DURATION -100 000.0

$LESSTHANDURATION BASE FIRST_ ~- ~-1000_000.0

$LINETERMINATOR ASCII.LF

$LOW PRIORITY 0

$MACHINECODE-STATEMENTCODE-0'(OP -> NOP);

$MACHINE CODE TYPE CODE_0

$MANTISSADOC 31

$MAXDIGITS 15

$MAXINT 2147483647

$MAXINTPLUS_1 2147483648

$MININT -2147483648

$NAME TINY INTEGER

A-3

MACRO PARAMETERS

$NAPIELIST 1860_SYSTEMV

SNAME-SPECIFICATIONi /net/prj7/860-sysv/aCvc-1 .11/ce,'X2120A

SNAZIESPECIFICATION2 /net/prj7/860-sysv/aCvc-1.11/ce/X2120B

SNAMESPECIFICATION3 /net/Prj7/860-sysv/aCVC-l 11/ce/X3119A

$NEGBASEDINT 16FOOOOOE#

$NEW MEM-SIZE 1234567

$NEWSTORUNIT 8

SNEWSYS-NAME 1860_SYSTEMV

$PAGETERMINATOR ASCII.FF

SRECORDDEFINITION RECORD SUBP: OPERAND; END RECORD;

$RECORDNMAE CALL_0

$TASKSIZE 32

$TASKSTORAGE-SIZE 1024

$TICK 0.01

$VARIABLEADDRESS FCNDECL .VARADDR

$VARIABLEADDRESS1 FCNDECL .VARADDR1

$VARIABLE ADDRESS2 FCNDECL .VARADDR2

$Y(XJR-PRAGMAL PRAQHAL PASSIVE

A-4

APPENDIX B

COMPILATION SYSTEM OPTIONS

The compiler options of this Ada implementation, as described in thisAppendix, are provided by the customer. Unless specifically notedotherwise, references in this appendix are to compiler documentation andnot to this report.

ada - invoke the Ada compiler

SYNTAX

ada (options] (sourcefile]... [objectfile.o]...

OPTIONS

-a file name (archive) Treat file name as an objectarchive file created-by ar. Since some archivefiles end with .a, -a is used to distinguisharchive files from Ada source files.

-A (disassemble) disassemble the units in the source fileafter compiling them. -A can be followed by arguments thatfurther define the disassembly display (e.g. -Aa, -Ab, -Ad,-Af, -Al, -As):

a add hexadecimal display of instruction bytes todisassembly listing

b disassemble the unit body [default]d print the data section (if present) as wellf use the alternative format for output1 put the disassembly output in file "file name.das"s disassemble the unit spec

-D identifier type value (define) Define an identifier of aspecified type and value. See VADS ADAPREPROCESSOR REFERENCE.

-d (dependencies) Analyze for dependencies only. Do not

do semantic analysis or code generation. Update the

B-1

COMPIIATION SYSTEM OPTIONS

library, marking any defined units as uncompiled. The-d option is used by a.make to establish dependenciesamong new files.

-e (error) Process compilation error messages using a.errorand send it to standard output. Only the source linescontaining errors are listed. Only one -e or -E optionshould be used.

-E-E file-E directory (error output) Without a file or directory

argument, ada processes error messages using a.error anddirects a brief output to standard output; the raw errormessages are left in ada source.err. If a file pathnameis given, the raw error -messages are placed in that file.If a directory argument is supplied, the raw error outputis placed in dir/source.err. The file of raw errormessages can be used as input to a.error.

-el (error listing) Intersperse error messages among sourcelines and direct to standard output.

-El-El file-El directory (error listing) Same as the -E option, except

that source listing with errors is produced.

-ev (error vi(l)) Process syntax error messages using a.error,embed them in the source file, and call the environmenteditor ERROR EDITOR. (If ERROR EDITOR is defined, theenvironment variable ERROR PATTERN should also be defined.ERROR PATIERN is an editor-search command that locates thefirst occurrence of '###' in the error file.) If no editoris specified, vi(l) is invoked.

-F (full DIANA) Do not trim the DIANA tree before outpuit tonet files. To save disk space, the DIANA tree will betrimmed so that all pointers to nodes that did not involvea subtree that define a symbol table will be nulled (unlessthose nodes are part of the body of an inline or generic orcertain other values needing to be retained for the debuggingor compilation information). The trinming generally removesinitial values of variables and all statements.

-K (keep) Keep the intermediate language (IL) file produced bythe compiler front end. The IL file will be placed in the.objects directory, with the file name Ada-source.

-L library_name (library) Operate in VADS library library_name.[Default: current working directory]

-ifile abbreviation (library search) This is an option passed tothe ld(l) linker telling it to search the

B-2


specified library file. (No space betweenthe -1 and the file abbreviation.) (self-hostonly)

For a description of the file abbreviations,see also Operating System documentation,ld(1).

-M unit name (main) Produce an executable program by linkingthe named unit as the main program. unit name mustalready be compiled. It must be either a7parameterless procedure or a parameterlessfunction returning an integer. The executableprogram will be named a.out (self-hosted) or a.vox(cross-development) unless overridden with the -ooption.

-M sourcefile (main) Produce an executable program by compilingand linking source file. The main unit of theprogram is assumed-to be the root name of the.a file (for foo.a the unit is foo). Only one.a file may be preceded by -M. The executableprogram will be named a.out (self-hosted) ora.vox (cross-development) unless overridden withthe -o option.

-o executable-file (output) This option is to be used inconjunction with the -M option. executable fileis the name of the executable rather than thedefault.

-0[0-9] (optimize) Invoke the code optimizer. An optional digit(there is no space before the digit) provides the levelof optimization. The default is -04.

-0 full optimization-00 no optimization-01 copy propagation, constant folding, removing

dead variables, subsuming moves between scalarvariables

-02 add common subexpression elimination withinbasic blocks

-03 add global common subexpression elimination-04 add hoisting invariants from loops and address

optimizations-05 add range optimizations, instruction

scheduling and one pass of reducing inductionexpressions

-06 no change and instruction scheduling-07 add one more pass of induction expression

reduction and instruction scheduling-08 add one more pass of induction expression

reduction and instruction scheduling-09 add one more pass of induction expression

B-3


reduction, instruction scheduling and hoistingexpressions common to the then and else parts ofif statements.

Hoisting from branches (and cases alternatives) canbe slow and does not always provide significantperformance gains so it can be suppressed.

For more information about optimization, seeCOMPILING ADA PROGRAMS, Compiler Optimizations andpragma OPTIMIZECODE(OFF).

-P Invoke the Ada Preprocessor. See VADS ADA PREPROCESSORREFERENCE.

-R VADSlibrary (recompile instantiation) Force analysis ofall generic instantiations, causingreinstantiation of any that are out of date.

-S (suppress) Apply pragma SUPPRESS to the entire compilationfor all suppressible checks. (See alsopragma SUPPRESS(ALLCHECKS)).

-sh (show) Display the name of the tool executable but do notexecute it.

-T (timing) Print timing information for the compilation.

-v (verbose) Print compiler version number, date and time ofcompilation, name of file compiled, command input line,total compilation time and error summary line. Storageusage information about the object file is provided.

-w (warnings) Suppress warning diagnostics.

DESCRIPTION

The command ada executes the Ada compiler and compiles thenamed Ada source file, ending with the .a suffix. The file mustreside in a VADS library directory. The ada.lib file in thisdirectory is modified after each Ada unit is compiled.

By default, ada produces only object and net files. If the-M option is used, the compiler automatically invokes a.ldand builds a complete program with the named library unit asthe main program.

Non-Ada object files (.o files produced by a compiler foranother language) may be given as arguments to ada. These fileswill be passed on to the linker and will be linked with thespecified Ada object files.

Command line options may be specified in any order, but the

order of compilation and the order of the files to be passed

B-4


to the linker can be significant.

Several VADS compilers may be simultaneously available on asingle system. Because the ada command in any VADS location/binon a system will execute the correct compiler components basedupon visible library directives, the option -sh is provided toprint the name of the components actually executed.

Program listings with a disassembly of machine codeinstructions are generated by a.db or a.das.

DIAGNOSTICS

The diagnostics produced by the VADS compiler are intended tobe self-explanatory. Most refer to the RM, Each RM referenceincludes a section number and optionally, a paragraph numberenclosed in parentheses.

RELATED TOPICS

a.app, a.das, a.db, a.error, a.help, a.ld, a.make, a.map, a.pr

LINKER OPTIONS

The linker options of this Ada implementation, as described in thisAppendix, are provided by the customer. Unless specifically notedotherwise, references in this appendix are to linker documentation and notto this report.

a.ld - prelinker

SYNTAX

a.ld [options) unitname [linker_options]

OPTIONS

-DO (objects) Use partially linked objects instead of archivesas an intermediate file if the entire list of objects cannotbe passed to the linker in one invocation. This option isuseful because of limitations in the archiver on some hosts(including Ultrix, HPUX and System V).

-DX (debug) Debug memory overflow (use in cases where linking alarge number of units causes the error message "local symboloverflow" to occur).

-E unit name (elaborate) Elaborate unit name as early in theelaboration order as possible.

-F (files) Print a list of dependent files in order and suppresslinking.

B-5

COMPILATION SYSTEM OPTIJNS

-L library_name (library) Operate in VADS library library_name.[Default: current working directory]

-o executable-file (output) Use the specified file name as thename of the output rather than the default(a.out (self-hosted) or a.vox(cross-development)).

-sh (show) Display the name of the tool executable but do notexecute it.

-U (units) Print a list of dependent units in order and

suppress linking.

-v (verbose) Print the linker comnand before executing it.

-v (verify) Print the linker command but suppress execution.

[linker options] All arguments after unit name are passedto the linker. These may be options for thelinker, archive libraries, library abbreviationsor object files.

DESCRIPTION

a.ld collects the object files needed to make unit name amain program and calls the ld(l) linker to link together allAda and other language objects required to produce an executableimage in a.out (self-hosted) or a.vox (cross- development).unit name is the main program and must name a non-genericsubprogram. If unit name is a function, it must return a valueof the type STANDARD.INTEGER. This integer result will be passedback to the shell as the status code of the execution. The utilityuses the net files produced by the Ada compiler to checkdependency information. a.ld produces an exception mapping tableand a unit elaboration table and passes this information to thelinker. The elaboration list generated by a.ld does not includelibrary level packages that do not need elaboration. In addition,packages that contain no code that can raise an exception will nolonger have exception tables.

a.ld reads instructions for generating executables from theada.lib file in the VADS libraries on the search list. Besidesinformation generated by the compiler, these directives alsoinclude WITHn directives that allow the automatic linking ofobject modules compiled from other languages or Ada objectmodules not named in context clauses in the Ada source. Anynumber of WITHn directives may be placed into a library, butthey must be numbered contiguously beginning at WITH1. Thedirectives are recorded in the library's ada.lib file and havethe following form.

WITH1:LINK:object file:

B-6


WITH2:LINK:archive file:

WITHn directives may be placed in the local Ada libraries or inany VADS library on the search list.

A WITHn directive in a local VADS library or earlier on thelibrary search list will hide the same numbered WITHn directivein a library later in the library search list.

Use the tool a.info to change or report library directives inthe current library.

All arguments after unit name are passed on to the linker.These may be options for-it, archive libraries, libraryabbreviations, or object files.

VADS location/bin/a.ld is a wrapper program that executes thecorrect executable based upon directives visible in the ada.libfile. This permits multiple VADS compilers to exist on the samehost. The -sh option prints the name of the actual executablefile.

FILES AND DIRECTORIES

a.out/a.vox default output file.nets Ada DIANA net files directory.objects/* Ada object filesVADS location/standard/* startup and standard library routines

DIAGNOSTICS

Self-explanatory diagnostics are produced for missing files,etc. Additional messages are produced by the ld linker.

RELATED TOPICS

ada, a.make, a.info

B-7

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 documentation 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 -2147483648 .. 2147483647;type SHORT INTEGER is range -32768 .. 32767;type TINY _NTEGER is range -128 .. 127;

type FLOAT isdigits 15 range -1.79796313486232E+308..1.79769313486232E+308;

type SHORTFLOAT is digits 6 range -3.40282E38 .. 3.40282E+38;

type DURATION is delta 0.001 range -2147483.648 .. 2147483.647;

end STANDARD;

C-I


APPENDIX F. Implementation-Dependent Characteristics

1. Implementation-Dependent Pragmas

1.1. INLINE ONLY Pragma

The INLINE ONLY pragma, when used in the same way as pragmaINLINE, iiidicates to the compiler that the subprogram mustalways be inlined. This pragma also suppresses the genera-tion of a callable version of the routine which saves codespace. If a user erroneously makes an INLINE ONLY subpro-gram recursive a warning message will be emitted and anPROGRAMERROR will be raised at run time.

1.2. BUILT IN Pragma

The BUILT IN pragma is used in the implementation of somepredefinea Ada packages, but provides no user access. It isused only to implement code bodies for which no actual Adabody can be provided, for example the MACHINECODE package.

1.3. SHARE CODE Pragma

The SHARE CODE pragma takes the name of a generic instantia-tion or a generic unit as the first argument and one of theidentifiers TRUE or FALSE as the second argument. Thispragma is only allowed immediately at the place of adeclarative item in a declarative part or package specifica-tion, or after a library unit in a compilation, but beforeany subsequent compilation unit.

When the first argument is a generic unit the pragma appliesto all instantiations of that generic. When the first argu-ment is the name of a generic instantiation the pragmaapplies only to the specified instantiation, or overloadedinstantiations.

If the second argument is TRUE the compiler will try toshare code generated for a generic instantiation with codegenerated for other instantiations of the same generic.When the second argument is FALSE each instantiation willget a unique copy of the generated code. The extent towhich code is shared between instantiations depends on thispragma and the kind of generic formal parameters declaredfor the generic unit.

The name pragma SHARE BODY is also recognized by the imple-mentation and has the same effect as SHARE CODE. It isincluded for compatability with earlier versions of VADS.

1.4. NO IMAGE Pragma

C-2

APPE•IDIX F OF THE Ada STANDARD

The pragma suppresses the generation of the image array usedfor the IMAGE attribute of enumeration types. This elim-inates the overhead required to store the array in the exe-cutable image. An attempt to use the IMAGE attribute on atype whose image array has been suppressed will result in acompilation warning and PROGRAM ERROR raised at run time.

1.5. EXTERNAL NAME Pragma

The EXTERNAL NAME pragma takes the name of a subprogram orvariable de-fined in Ada and allows the user to specify adifferent external name that may be used to reference theentity from other languages. The pragma is allowed at theplace of a declarative item in a package specification andmust apply to an object declared earlier in the same packagespecification.

1.6. INTERFACE NAME Pragma

The INTERFACE NAME pragma takes the name of a a variable orsubprogram defined in another language and allows it to bereferenced directly in Ada. The pragma will replace alloccurrences of the variable or subprogram name with anexternal reference to the second, link argument. The pragmais allowed at the place of a declarative item in a packagespecification and must apply to an object or subprogramdeclared earlier in the same package specification. Theobject must be declared as a scalar or an access type. Theobject cannot be any of the following:

a oop variable,a constant,an initialized variable,an array, ora record.

1.7. IMPLICIT CODE Pragma

Takes one of the identifiers ON or OFF as the single argu-ment. This pragma is only allowed within a machine codeprocedure. It specifies that implicit code generated by thecompiler be allowed or disallowed. A warning is issued ifOFF is used and any implicit code needs to be generated.The default is ON.

1.8. OPTIMIZE CODE Pragma

Takes one of the identifiers ON or OFF as the single argu-ment. This pragma is only allowed within a machine codeprocedure. It specifies whether the code should be optim-ized by the compiler. The default is ON. When OFF isspecified, the compiler will generate the code as specified.

C-3


2. Implementation of Predefined Pragmas

2.1. CONTROLLED

This pragma is recognized by the implementation but has noeffect.

2.2. ELABORATE

This pragma is implemented as described in Appendix B of theAda RM.

2.3. INLINE


2.4. INTERFACE

This pragma supports calls to 'C' and FORTRAN functions. TheAda subprograms can be either functions or procedures. Thetypes of parameters and the result type for functions mustbe scalar, access or the predefined type ADDRESS in SYSTEM.All parameters must have mode IN. Record and array objectscan be passed by reference using the ADDRESS attribute.

2.5. LIST

This pragma is implemented as described in Appendix B of theAda Rm.

2.6. MEMORY SIZE

This pragma is recognized by the implementation. The imple-mentation does not allow SYSTEM to be modified by means ofpragmas, the SYSTEM package must be recompiled.

2.7. NON REENTRANT

This pragma takes one argument which can be the name ofeither a library subprogram or a subprogram declared immedi-ately within a library package spec or body. It indicatesto the compiler that the subprogram will not be calledrecursively allowing the compiler to perform specific optim-izations. The pragma can be applied to a subprogram or aset of overloaded subprograsm within a package spec or pack-age body.

2.8. NOT ELABORATED

This pragma can only appear in a library package specifica-tion. It indicates that the package will not be elaboratedbecause it is either part of the RTS, a configuration pack-

C-4


age or an Ada package that is referenced from a languageother than Ada. The presence of this pragma suppresses thegeneration of elaboration code and issues warnings if ela-boration code is required.

2.9. OPTIMIZE


2.10. PACK

This pragma will cause the compiler to choose a non-alignedrepresentation for composite types. It will not causesobjects to be packed at the bit level.

2.11. PAGE


2.12. PASSIVE

The pragma has three forms

PRAGMA PASSIVE;PRAG(A PASSIVE(SEMAPHORE);PRAGMA PASSIVE( INTERRUPT, <number>);

This pragma Pragma passive can be applied to a task or tasktype declared immediately within a library package spec orbody. The pragma directs the compiler to optimize certaintasking operations. It is possible that the statements in atask body will prevent the intended optimization, in thesecases a warning will be generated at compile time and willraise TASKINGERROR at runtime.

2.13. PRIORITY

This pragma is implemented as described in Appendix B of theAda RN.

2.14. SHARED


2.15. STORAGE UNIT


C-5


2.16. SUPPRESS

This pragma is implemented as described, except thatDIVISION CHECK and in some cases OVERFLOW-CHECK cannot besupresse3.

2.17. SYSTEM NAME


3. Implementation-Dependent Attributes

3.1. P'REF

For a prefix that denotes an object, a program unit, alabel, or an entry:

This attribute denotes the effective address of the first ofthe storage units allocated to P. For a subprogram, pack-age, task unit, or label, it refers to the address of themachine code associated with the corresponding body orstatement. For an entry for which an address clause hasbeen given, it refers to the corresponding hardware inter-rupt. The attribute is of the type OPERAND defined in thepackage MACHINE CODE. The attribute is only allowed withina machine code procedure.

See section F.4.8 for more information on the use of thisattribute.

(For a package, task unit, or entry, the 'REF attribute isnot supported.)

3.2. T'TASKID

For a task object or a value T, T'TASK ID yields the uniquetask id associated with a task. The vialue of this attributeis of the type ADDRESS in the package SYSTEM.

4. Specification Of Package SYSTEM

- Copyright 1987, 1988, 1989, 1990 Verdix Corporation- Preserve line numbers as they are reported in ACVC tests.

with unsigned types;package SYSTEM is

pragma suppress(ALLCHECKS);

C-6


pragma suppress(EXCEPTIONTABLES);pragma notelaborated;

type NAME is ( i860_System_V );

SYSTEM NAME : constant NAME :- i860_SystemV;STORAGE UNIT constant :- 8;MEMORYSIZE : constant :- 16_777_216;

- System-Dependent Named Numbers

MIN INT : constant :- -2 147 483 648;MAX-INT : constant :- 2 147 _83 647;MAX-DIGITS : constant : 5; -1 -MAX MANTISSA constant := 31;FINE DELTA : constant :2.0*(-31);TICK : constant := 0.01;

- Other System-dependent Declarations

subtype PRIORITY is INTEGER range 0 .. 99;

MAXRECSIZE : integer := 64*1024;

type ADDRESS is private;

function ">" (A: ADDRESS; B: ADDRESS) return BOOLEAN;function "<" (A: ADDRESS; B: ADDRESS) return BOOLEAN;function ">-"(A: ADDRESS; B: ADDRESS) return BOOLEAN;function "<-"(A: ADDRESS; B: ADDRESS) return BOOLEAN;function "-" (A: ADDRESS; B: ADDRESS) return INTEGER;function "+" (A: ADDRESS; I: INTEGER) return ADDRESS;function "-" (A: ADDRESS; I: INTEGER) return ADDRESS;

function "+" (I: UNSIGNED TYPES.UNSIGNEDINTEGER) return ADDRESS;

function MEMORY ADDRESS(I: UNSIGNED TYPES.UNSIGNED INTEGER) return ADDRESS rename-. "+"

NO ADDR : constant ADDRESS;

type TASKID is private;

NO_TASKID : constant TASKID;

type PROGRAM ID is private;NO PROGRAM ID : constant PROGRAM ID;

private

type ADDRESS is new UNSIGNED TYPES. UNSIGNEDINTEGER;NO ADMR : constant ADDRESS := 0;

C-7


pragma BUILT IN(">");pragma BUILT IN("<");pragma BUILT IN( ">-");pragma BUILT-IN( "<-");pragma BUILT IN("-") ;pragma BUILTIN( "+");

type TASK ID is new UNSIGNED TYPES.UNSIGNEDINTEGER;NOTASK ID : constant TASKID :- 0;

type PROGRAMID is new UNSIGNEDTYPES.UNSIGNEDINTEGER;NO PROGRAM ID : constant PROGRAM ID := 0;

end SYSTEM;

5. Restrictions On Representation Clauses

5.1. Pragma PACK

In the absence of pragma PACK record components are paddedso as to provide for efficient access by the targethardware, pragma PACK applied to a record eliminate the pad-ding where possible. Pragma PACK has no other effect on thestorage allocated for record components a record representa-tion is required.

5.2. Size Clauses

For scalar types a representation clause will pack to thenumber of bits required to represent the range of the sub-type. A size clause applied to a record type will not causepacking of components; an explicit record representationclause must be given to specify the packing of the com-ponents. A size clause applied to a record type will causepacking of components only when the component type is adiscrete type. An error will be issued if there is insuffi-cient space allocated. The SIZE attribute is not supportedfor task, access, or floating point types.

5.3. Address Clauses

Address clauses are only supported for variables. Sincedefault initialization of a variable requires evaluation ofthe variable address elaboration ordering requirementsprohibit inititalization of a variables which have addressclauses. The specified address indicates the physicaladdress associated with the variable.

5.4. Interrupts

Interupt entries are not supported.

C-8


5.5. Representation Attributes

The ADDRESS attribute is not supported for the followingentities:

PackagesTasksLabelsEntries

5.6. Machine Code Insertions

Machine code insertions are supported.

The general definition of the package MACHINE CODE providesan assembly language interface for the target machine. Itprovides the necessary record type(s) needed in the codestatement, an enumeration type of all the opcode mneumonics,a set of register definitions, and a set of addressing modefunctions.

The general syntax of a machine code statement is as fol-

lows:

CODE n'( opcode, operand f, operand} );

where n indicates the number of operands in the aggregate.

A special case arises for a variable number of operands.The operands are listed within a subaggregate. The formatis as follows:

CODEN'( opcode, (operand {, operand}) );

For those opcodes that require no operands, named notationmust be used (cf. RM 4.3(4)).

CODEO'( op -> opcode );

The ode must be an enumeration literal (i.e. it cannot bean object, attribute, or a rename).

An operand can only be an entity defined in MACHINECODE orthe 'REF attribute.

The arguments to any of the functions defined inMACHINE CODE must be static expressions, string literals, orthe functions defined in MACHINE CODE. The 'REF attributemay not be used as an argument in any of these functions.

Inline expansion of machine code procedures is supported.

C-9


6. Conventions for Implementation-generated Names

There are no implementation-generated names.

7. Interpretation of Expressions in Address Clauses

Address expressions in an address clause are interpreted asphysical addresses.

8. Restrictions on Unchecked Conversions

None.

9. Restrictions on Unchecked Deallocations

None.

10. Implementation Characteristics of I/O Packages

Instantiations of DIRECT 10 use the value MAX REC SIZE asthe record size (expressed in STORAGE UNITS) when-the sizeof ELEMENT TYPE exceeds that value. For-example for uncon-strained arrays such as string where ELEMENT TYPE'SIZE isvery large, MAX REC SIZE is used instead. MAX RECORD SIZEis defined in SYSTEM and can be changed by a program beforeinstantiating DIRECT 10 to provide an upper limit on therecord size. In any case the maximum size supported is 1024x 1024 x STORAGE UNIT bits. DIRECT 10 will raise USEERRORif MAX RECSIZE exceeds this absolute limit.

Instantiations of SEQUENTIAL 10 use the value MAX REC SIZEas the record size (expressed in STORAGE UNITS) when thesize of ELEMENT TYPE exceeds that value. For example forunconstrained irrays such as string where ELEMENT TYPE'SIZEis very large, MAX REC SIZE is used instead.MAX RECORD SIZE is defineU in-SYSTEM and can be changed by aprogram before instantiating INTEGER 10 to provide an upperlimit on the record size. SEQUENTIAL 10 imposes no limit onMAX RECSIZE.

11. Implementation Limits

The following limits are actually enforced by the implemen-tation. It is not intended to imply that resources up to oreven near these limits are available to every program.

11.1. Line Length

The implementation supports a maximum line length of 500

C-10


characters including the end of line character.

11.2. Record and Array Sizes

The maximum size of a statically sized array type is4,000,000 x STORAGE UNITS. The maximum size of a staticallysized record type is 4,000,000 x STORAGE UNITS. A recordtype or array type declaration that exceeds these limitswill generate a warning message.

11.3. Default Stack Size for Tasks

In the absence of an explicit STORAGE SIZE length specifica-tion every task except the main program is allocated a fixedsize stack of 10,240 STORAGE UNITS. This is the valuereturned by T'STORAGESIZE for a task type T.

11.4. Default Collection Size

In the absence of an explicit STORAGE SIZE length attributethe default collection size for an a-cess type is 100 timesthe size of the designated type. This is the value returnedby T'STORAGE SIZE for an access type T.

11.5. Limit on Declared Objects

There is an absolute limit of 6,000,000 x STORAGE UNITS forobjects declared statically within a compilation unit. Ifthis value is exceeded the compiler will terminate the comp-ilation of the unit with a FATAL error message.

C-11

R 11 jjjjjjj'ljlll jjll 348 j1 11i1111' 'lIi N PAGE F ... AD-A260 11 jjjjjjj'ljlll jjll 348j1...

Documents

Transcript of R 11 jjjjjjj'ljlll jjll 348 j1 11i1111' 'lIi N PAGE F ... AD-A260 11 jjjjjjj'ljlll jjll 348j1...