Programmer's ROM - The Computer Language Library

home *** CD-ROM | disk | FTP | other *** search

/ Programmer's ROM - The Computer Language Library / programmersrom.iso / ada / order / compord.doc < prev next >

Wrap

Text File | 1988-05-03 | 73.4 KB | 2,456 lines

--:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: --read.me --:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: To build the compile order tool: 1. Compile all the abstractions into a program library (see READ.ME in abstractions directory for details). 2. Compile everything named in the COMPORD.CO file into the program library containing the abstractions or a sublibrary whose parent library contains all the abstractions. COMPORD.CO lists file names in the correct compilation order. 3. Link compile_order with the program library where everything was compiled. To do this using the DEC Ada compiler type: $ acs link compile_order To run the tool on VMS: 1. Define a logical symbol for the executable of compile_order. For example, compile_order :== $DRB1:[NOSC.TOOLS.COMPORD]COMPORD.EXE NOTE: The full path name of the executable is required in the definition of the symbol. The pathname given here is just an example and will be different on your system. 2. Enter the command with appropriate parameters. compile_order ( Source_list=>("test_filename") [, Output=>"output_file"] [, Units_File=>"unit_file"] [, Which_Report=>report_type] ); Entering the command compile_order with no parameters gives a brief description of how to use the tool. For example, compile_order ( Source_List=>("test1.tst"), Which_Report=>raw); -- In this case the input file is test1.tst, and the output will go to the -- default output. The report will be in raw form. -- More than one file is allowed in the Source_List, as are wildcards. compile_order ( Source_List=>("test1.tst", "test.*"), Output=>"report.rpt") -- In this case there are a list of files for input and the report defaults -- to be in full format. Files contained in this directory: COMPORD.CO -- Compilation order for compile order sources COMPORD.EXE -- VMS 4.0 compile order executable The [.SOURCE] subdirectory contains most of the sources that make up the compile order tool. Other sources are contained in the abstractions directory. Files in [.SOURCE]: The source files that make up the compile order tool are as follows: CDRIVER.ADA -- the driver which deals with the command line COMPORD.SPC -- the main procedure of the program COMPORD.BDY CMPUTIL.SPC -- the procedures which control the actions done by the parser MPUTIL.BDY REPORT.SPC -- the procedures which output the reports from the information REPORT.BDY -- gathered LOOKUP.SPC -- the data structure and procedures for looking up additional LOOKUP.BDY -- file information supplied in units_file. UNITDAG.SPC -- instantiations of the dags and other things used by the dags -- like the node types, and hash function MINIDAG.SPC -- instantiation of another dag COPKG.DAT -- global variables for the program The tool runs using the parser. Most of the sources needed for the parser are in the parser abstraction. The four units that are unique to this tool are as follows: APPLYACT.SUB -- A subunit of the parser which calls the action routines. GETNEXT.SUB -- A subunit of the lexer which gets each token and only -- returns non comment tokens to the lexer. PTBLS.BDY -- The parse tables body. GRMCONST.BDY -- Grammar constants for the parse tables. The [.TEST] subdirectory contains the tests used in testing compile order. Files in [.TEST]: Test files end in the extension ".tst" TEST1.TST: tests wrap around by nesting withs very deeply. TEST2.TST: tests handling of a syntax error. TEST3.TST: has no errors tests normal operation. TEST4.TST: tests handling of separate bodies and inlines. TEST5.TST: tests the handling of incorrect order within a file. TEST6.TST: tests handling of a cycle between units. TEST7.TST: test7, and test8 together test units having the TEST8.TST: same name. CYCLE1.TST: together with fcycle2 tests handling of a cycle FCYCLE2.TST: between files. The result files that were generated have an extension ".rpt" Report files using everything other than full report format were generated from test3.tst (the normal input). These are: raw.rpt, depend.rpt, rawdep.rpt, comp.rpt, rawcomp.rpt, file.rpt, units.rpt. In the cases of files which tested errors the output files may be empty or incomplete. The [.DOC] subdirectory contains the documentation for compile order. Files in [.DOC]: USERMAN.MEM -- Compile order user's manual USERMAN.RNO -- Runoff input for user's manual RELEASE.NTS -- Release notes COMPGRM.LIS -- Listing of compile order grammar. The rule numbers in this file may be used to make changes to the case statement in the Apply_Actions subunit. COMPORD.CNT -- Statement counts and line counts of compile order source files. --:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: --userman.mem --:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: COMPILATION ORDER REPORT ___________ _____ ______ ___________ _____ ______ 1 COMPILATION ORDER REPORT ___________ 1.1 Description This tool produces a pair of reports. One report shows both _____ _________ withs and withed-by dependencies between library units for the files in the Source_List. The other report lists library units, and files in their compilation order. In general, when there is one compilation unit per file these two lists would tend to be the same, but there may be more than one compilation unit within a file, and in these cases the two lists will differ and we need to be able to tell when there is a problem in one of these files. _______ ______ 1.2 Command Format type REPORT_TYPE is (FULL, RAW, DEPENDENCY, RAW_DEPENDENCY, COMPILATION, RAW_COMPILATION, RAW_COMPILATION, UNITS_ORDER, FILE_ORDER); COMPILE_ORDER ( SOURCE_LIST : in STRING_ARRAY; OUTPUT : in STRING := ""; UNITS_FILE : in STRING := ""; WHICH_REPORT : in REPORT_TYPE := FULL ); Source_List This is the list of files to be scanned for dependencies. They should be names of Ada source code files. There must be at least one input file in the list. Also wild cards are allowed in the . named, so a valid input is Source_List => (.ada). The format of the list is the names of input files enclosed in parenthesis with commas separating the names. Output This is the name of an output file to put the report in. If there is no name the report will go to standard output. Units_File This is the name of a file which contains information about the file name corresponding to a particular unit. If there is no name it assumes there is no additional input and no look ups will be done. See the description of a units file below. Which_Report This indicates which of the output options to use. The default is to print out the full report. The possible values for Which_Report are: FULL, RAW, DEPENDENCY, RAW_DEPENDENCY, COMPILATION, RAW_COMPILATION, RAW_COMPILATION, UNITS_ORDER and FILE_ORDER. Page 2 ___ __________ ______ 1.3 The Dependency Report The dependency report shows the withs and withed-by dependencies between units. The first half is the withs dependencies. Units which are at the top of a withs tree (i.e. they are not withed-by any other unit) are written at the left margin. Each level of withs relative to these units is indented two spaces to the right. To avoid repetition of a unit and any dependencies it has that have already been shown, the name of a unit enclosed in braces indicates that the information has already been printed in the report. The name will be written in braces in all places except the first use. If the dependencies become so deeply nested that a name would go off the edge of the page, the output wraps around. To indicate a wrap around there are four asterisks at the beginning of the line and the last name printed is repeated for context. The withed-by list is similar to the withs list so there is no need to describe it in detail. The withed-by list is useful for determining the potential expense of making a change to a unit which is being used by other units in the library. At the very least, all dependent (withed-by) units will require recompilation; some may require modification, depending upon what kind of a change is contemplated. ___ ____________ ________ 1.4 The Dependencies Analyzed Most of the dependecies in the report will be the obvious ones where one unit withs another in a with clause. Other dependencies are possible however, and handled by this tool. These other dependencies are in the cases of pragma inlines and generic instantiations. If there is a pragma inline an implicit dependency on the body of that unit is created. In the case of generic instantiations some compilers create a dependency on the body of the generic unit. Both of these types of dependencies are reflected in the reports generated by this tool. See the installation note for how to turn the generic dependencies on. ___ ___________ _____ ____ 1.5 The Compilation Order List By analyzing the dependencies gathered for the dependency report we will create a compilation order list which will work. Obviously, in the case of many units which are independent there are any number of orders that will work, but this report will only produce one. It produces two different compilation lists. One based on the compilation units, the other based on the file names. Where the file name is known it is also reported in the unit list. In cases where the file is not known (e.g. a with of TEXT_IO) the file name field contains "(not found)". File names supplied in the Units_file are marked with a "#" before the name so they would not be confused with files analysed. Page 3 When there are cycles in the dependencies (either between units or files) the dependencies that caused the cycles will be reported at the begining of the output. The tables and compilation lists reflect the dependencies ignoring the ones which caused the cycles. So any tables generated when there are cycles should not be used to with other tools until the problem is fixed. It is also possible that the order of units within a file could cause a problem when a file contains more that one compilation unit. These units are flagged with an asterisk at the end of the unit name. Reversing the order of the compilation units within the file should solve this problem. When there is a syntax error in the file, the tool will indicate where the error is and continue with the next file. Units in any files which are skipped this way will not be in the report. Also, if two files contain compilation units with the same name the error is flagged and the second file is ignored. The report continues with the next file in the source list. _____ __ ___ ____ 1.6 Input To The Tool The input is a list of source files to scan for the necessary information. It will scan for withs clauses and the package, procedure or function associated with the withs. For tool to scan the file properly the contents of the input files must be Ada. Additional input to the tool can be supplied through the Units_File. This file will be scanned for the file names fo units which would otherwise be listed as "not found". The format of this file is first the file name followed by the unit name, followed by the unit type (i.e. (spec), (body) or (separate body) ). There should be the information for one unit on each line. In the report file names found by look up are marked with a "#" before the name. A Units_File in the form of a units_order previously generated is accepted by the tool with the "#" in front of any file name being ignored if there is one. ___ ______ _______ 1.7 The Output Options There are eight different forms for the output. The default form is the full form where both dependencies and compilation order reports will be written with the output paginated and headers at the top of columns. Another form is raw mode, where the same information will be printed, but the output will not be paginated and there will be no headers. This is to allow the output to be fed as the input to another tool. The other forms are a combination of these two. The next is just the dependency report with nice formatting, and related to this is the dependency report in raw form. There are four different forms of the compilation order report. The first one is the compilation order report with nice output. The next is the same information, but in raw Page 4 form. The final two options are just the compilation units in raw form, and just the file order in raw form. _______ 1.8 Example The following is an example of invoking the compilation order report. Compile_order (SOURCE_LIST =>("driver.spc", "graphs.spc", "scanner.spc"), OUTPUT=> "report.co", UNITS_FILE=>"file.txt", WHICH_REPORT=>FULL); If the files given contained the example compilation units below, the report generated from this call would look like this: Page 5 Compilation Report April 5, 1985 page 1 Dependency Report: Withs dependencies: driver (spec) graph (spec) tables (spec) scanner (spec) Error_Message (spec) TEXT_IO (spec) {TEXT_IO (spec)} flowgraph (spec) {graph (spec)} {tables (spec)} Withed-by Dependencies: tables (spec) flowgraph (spec) graph (spec) driver (spec) TEXT_IO (spec) Error_Message (spec) scanner (spec) {driver (spec)} {scanner (spec)} Compilation List: File Name Compilation Unit (not found) TEXT_IO (spec) # table.spc tables (spec) scanner.spc Error_Message (spec) scanner.spc scanner (spec) graphs.spc graph (spec) driver.spc driver (spec) graphs.spc flowgraph (spec) File Order: scanner.spc graphs.spc driver.ada This goes directly to the file given as Output or to the default output. Page 6 Note that units which are not in the files given are shown, and any information know is also given. For example, tables.spc was not given as an input file, but if file.txt had contained the record: table.spc tables (spec) the report would come out as shown with "# table.spc" in the units compilation order. It should be remembered that these files were not scanned for withs and any dependencies they may have are not reflected in the report. Units that are not in one of the input files or named in the Units file are still shown as "not found". ____________ ____ 1.9 Installation Note Generic instantiations may be handled differently by different compilers since it is left open to interpretation by the Language Reference Manual. Some compilers may create a dependency on the generic's body when the generic is instantiated while others may not. Always adding this dependency would not be wrong but it would cause somethimes unnecessary dependencies which should be avoided. So to have generic instantiations create a dependency, the variable do_generics in compile_order_declarations should be set true. One minor problem with adding these dependencies is that syntactically a the instantiation of a local generic looks no different from an external one. This results in local generics being treated the same way as an external one, and showing up in the report as distinct units which they are not. They can, however, be ignored and do not effect the ordering in any other way. --:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: --userman.rno --:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: .FLAG BOLD .HEADER LEVEL 1^*^&COMPILATION ORDER REPORT\&\* .HEADER LEVEL 2^&Description\& .PARAGRAPH This tool produces a pair of reports. One report shows both ^&withs\& and ^&withed-by\& dependencies between library units for the files in the Source__List. The other report lists library units, and files in their compilation order. In general, when there is one compilation unit per file these two lists would tend to be the same, but there may be more than one compilation unit within a file, and in these cases the two lists will differ and we need to be able to tell when there is a problem in one of these files. .HEADER LEVEL 2^&Command Format\& .LITERAL type REPORT_TYPE is (FULL, RAW, DEPENDENCY, RAW_DEPENDENCY, COMPILATION, RAW_COMPILATION, RAW_COMPILATION, UNITS_ORDER, FILE_ORDER); COMPILE_ORDER ( SOURCE_LIST : in STRING_ARRAY; OUTPUT : in STRING := ""; UNITS_FILE : in STRING := ""; WHICH_REPORT : in REPORT_TYPE := FULL ); .END LITERAL .BLANK .LEFT MARGIN 20 .TAB STOP 20 .INDENT -15 Source__List This is the list of files to be scanned for dependencies. They should be names of Ada source code files. There must be at least one input file in the list. Also wild cards are allowed in the named, so a valid input is Source__List => (*.ada). The format of the list is the names of input files enclosed in parenthesis with commas separating the names. .INDENT -15 Output This is the name of an output file to put the report in. If there is no name the report will go to standard output. .INDENT -15 Units__File This is the name of a file which contains information about the file name corresponding to a particular unit. If there is no name it assumes there is no additional input and no look ups will be done. See the description of a units file below. .INDENT -15 Which__Report This indicates which of the output options to use. The default is to print out the full report. The possible values for Which__Report are: FULL, RAW, DEPENDENCY, RAW__DEPENDENCY, COMPILATION, RAW__COMPILATION, RAW__COMPILATION, UNITS__ORDER and FILE__ORDER. .TAB STOP 0 .LEFT MARGIN 0 .HEADER LEVEL 2^&The Dependency Report\& .PARAGRAPH The dependency report shows the withs and withed-by dependencies between units. The first half is the withs dependencies. Units which are at the top of a withs tree (i.e. they are not withed-by any other unit) are written at the left margin. Each level of withs relative to these units is indented two spaces to the right. To avoid repetition of a unit and any dependencies it has that have already been shown, the name of a unit enclosed in braces indicates that the information has already been printed in the report. The name will be written in braces in all places except the first use. If the dependencies become so deeply nested that a name would go off the edge of the page, the output wraps around. To indicate a wrap around there are four asterisks at the beginning of the line and the last name printed is repeated for context. .PARAGRAPH The withed-by list is similar to the withs list so there is no need to describe it in detail. The withed-by list is useful for determining the potential expense of making a change to a unit which is being used by other units in the library. At the very least, all dependent (withed-by) units will require recompilation; some may require modification, depending upon what kind of a change is contemplated. .HEADER LEVEL 2^&The Dependencies Analyzed\& .PARAGRAPH Most of the dependecies in the report will be the obvious ones where one unit withs another in a with clause. Other dependencies are possible however, and handled by this tool. These other dependencies are in the cases of pragma inlines and generic instantiations. If there is a pragma inline an implicit dependency on the body of that unit is created. In the case of generic instantiations some compilers create a dependency on the body of the generic unit. Both of these types of dependencies are reflected in the reports generated by this tool. See the installation note for how to turn the generic dependencies on. .HEADER LEVEL 2^&The Compilation Order List\& .PARAGRAPH By analyzing the dependencies gathered for the dependency report we will create a compilation order list which will work. Obviously, in the case of many units which are independent there are any number of orders that will work, but this report will only produce one. It produces two different compilation lists. One based on the compilation units, the other based on the file names. Where the file name is known it is also reported in the unit list. In cases where the file is not known (e.g. a with of TEXT__IO) the file name field contains "(not found)". File names supplied in the Units__file are marked with a "_#" before the name so they would not be confused with files analysed. .PARAGRAPH When there are cycles in the dependencies (either between units or files) the dependencies that caused the cycles will be reported at the begining of the output. The tables and compilation lists reflect the dependencies ignoring the ones which caused the cycles. So any tables generated when there are cycles should not be used to with other tools until the problem is fixed. .PARAGRAPH It is also possible that the order of units within a file could cause a problem when a file contains more that one compilation unit. These units are flagged with an asterisk at the end of the unit name. Reversing the order of the compilation units within the file should solve this problem. .PARAGRAPH When there is a syntax error in the file, the tool will indicate where the error is and continue with the next file. Units in any files which are skipped this way will not be in the report. Also, if two files contain compilation units with the same name the error is flagged and the second file is ignored. The report continues with the next file in the source list. .HEADER LEVEL 2^&Input to the Tool\& .PARAGRAPH The input is a list of source files to scan for the necessary information. It will scan for withs clauses and the package, procedure or function associated with the withs. For tool to scan the file properly the contents of the input files must be Ada. Additional input to the tool can be supplied through the Units__File. This file will be scanned for the file names fo units which would otherwise be listed as "not found". The format of this file is first the file name followed by the unit name, followed by the unit type (i.e. (spec), (body) or (separate body) ). There should be the information for one unit on each line. In the report file names found by look up are marked with a "_#" before the name. A Units__File in the form of a units__order previously generated is accepted by the tool with the "_#" in front of any file name being ignored if there is one. .HEADER LEVEL 2^&The Output Options\& .PARAGRAPH There are eight different forms for the output. The default form is the full form where both dependencies and compilation order reports will be written with the output paginated and headers at the top of columns. Another form is raw mode, where the same information will be printed, but the output will not be paginated and there will be no headers. This is to allow the output to be fed as the input to another tool. .PARAGRAPH The other forms are a combination of these two. The next is just the dependency report with nice formatting, and related to this is the dependency report in raw form. There are four different forms of the compilation order report. The first one is the compilation order report with nice output. The next is the same information, but in raw form. The final two options are just the compilation units in raw form, and just the file order in raw form. .HEADER LEVEL 2^&Example\& .PARAGRAPH The following is an example of invoking the compilation order report. .LITERAL Compile_order (SOURCE_LIST =>("driver.spc", "graphs.spc", "scanner.spc"), OUTPUT=> "report.co", UNITS_FILE=>"file.txt", WHICH_REPORT=>FULL); .END LITERAL .BLANK If the files given contained the example compilation units below, the report generated from this call would look like this: .PAGE .LITERAL Compilation Report April 5, 1985 page 1 Dependency Report: Withs dependencies: driver (spec) graph (spec) tables (spec) scanner (spec) Error_Message (spec) TEXT_IO (spec) {TEXT_IO (spec)} flowgraph (spec) {graph (spec)} {tables (spec)} Withed-by Dependencies: tables (spec) flowgraph (spec) graph (spec) driver (spec) TEXT_IO (spec) Error_Message (spec) scanner (spec) {driver (spec)} {scanner (spec)} Compilation List: File Name Compilation Unit (not found) TEXT_IO (spec) # table.spc tables (spec) scanner.spc Error_Message (spec) scanner.spc scanner (spec) graphs.spc graph (spec) driver.spc driver (spec) graphs.spc flowgraph (spec) File Order: scanner.spc graphs.spc driver.ada .END LITERAL .BLANK This goes directly to the file given as Output or to the default output. .BLANK Note that units which are not in the files given are shown, and any information know is also given. For example, tables.spc was not given as an input file, but if file.txt had contained the record: .LITERAL table.spc tables (spec) .END LITERAL the report would come out as shown with "_# table.spc" in the units compilation order. It should be remembered that these files were not scanned for withs and any dependencies they may have are not reflected in the report. Units that are not in one of the input files or named in the Units file are still shown as "not found". .HEADER LEVEL 2^&Installation Note\& .PARAGRAPH Generic instantiations may be handled differently by different compilers since it is left open to interpretation by the Language Reference Manual. Some compilers may create a dependency on the generic's body when the generic is instantiated while others may not. Always adding this dependency would not be wrong but it would cause somethimes unnecessary dependencies which should be avoided. So to have generic instantiations create a dependency, the variable do__generics in compile__order__declarations should be set true. One minor problem with adding these dependencies is that syntactically a the instantiation of a local generic looks no different from an external one. This results in local generics being treated the same way as an external one, and showing up in the report as distinct units which they are not. They can, however, be ignored and do not effect the ordering in any other way. .PAGE --:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: --release.nts --:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: Release Notes for the compord tool (May 1985) 1. Implementation changes: The lower level of the tool changed completely in implementation, and the other units were restructured to make more sense with the new implementation. So, all code previously shipped is completely out of date as everything changed in one way or another. 2. Interface changes: An additional parameter was added as requested. It is called UNITS_FILE. The use of this file is that when producing a report if the file name field is not known for a unit before saying "(not found)" it will try to look it up in the units file. Any files found this way will be marked with a '#' in the first column. The contents of this file are a lists of files and their contents in the following format: [#] <filename> <unit name> <unit type> <filename> is the name of the file which contains the unit <unit name> <unit name> is the name of the unit. <unit type> is one of (spec), (body), (separate body). The unit type is necessary since compord does not think of a unit simply in terms of its name, but in terms of the name and the type because the type effects the types of dependecies it has. Using the above format allows the user to use a units_order report as a unit_file input. It accepts both a plain units_order and also one with '#' signs in the first column indicating that the name was looked up previously in a units file. 3. Driver changes: It now accepts full Ada syntax on the command line (including ';'). The command is echoed back if no errors were found on the command line. 4. Dependency changes: In addtions to implicits withs generated by bodies and pragma inlines, an implicit with can be generated for instantiations of generics. Some compilers will create a dependency from the unit where the instantiation is to the body of the generic unit, but not all compilers. In order to only do this when it is needed there is a variable in the package compile_order_declarations called do_generics which should be set according to the type of compiler the user has. It is alright to always have it on, but some anomalies might creep into the report. These result from the fact that in a body (where the instantiation would be) compord cannot tell from syntax alone whether the generic is an external one which creates a real dependency, or a generic that was declared in the spec of the present unit. In the second case it decides to put in the extra dependency since it seemed better to put in all the dependecies it thinks are there rather than none. These 'local' generics will not have an associated filename and will not effect the correctnes of any of the other reports. --:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: --compgrm.lis --:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: Options in Effect DEFAULT TABLES DEFMARK = % ORMARK = | BLOCKB = /. BLOCKE = ./ COMMB = -- COMME = LOADF = 70 Grammar Constants Number of Terminals 94 Number of Non Terminals 222 Number of Rules 477 Number of Items 1637 Number of states 949 Number of shift entries 1548 Number of goto entries 2156 Number of reduce entries 158 Number of entries saved by default reductions 5809 Number of shift/reduce conflicts 0 Number of reduce/reduce conflicts 0 The following symbols are not used in any right hand side comment_literal Terminalss ABORT ABS ACCEPT ACCESS ALL AND ARRAY AT BEGIN BODY CASE CONSTANT DECLARE DELAY DELTA DIGITS DO ELSE ELSIF END ENTRY EXCEPTION EXIT FOR FUNCTION GENERIC GOTO IF IN IS LIMITED LOOP MOD NEW NOT NULL OF OR OTHERS OUT PACKAGE PRAGMA PRIVATE PROCEDURE RAISE RANGE RECORD REM RENAMES RETURN REVERSE SELECT SEPARATE SUBTYPE TASK TERMINATE THEN TYPE USE WHEN WHILE WITH XOR identifier numeric_literal string_literal character_literal & ' ( ) * + , - . / : ; < = > '|' => .. ** := /= >= <= << >> <> comment_literal Rules 1 pragma ::= PRAGMA pragma_id ( general_component_associations ) ; 2 pragma ::= PRAGMA identifier ; 3 pragma_id ::= identifier 4 basic_declaration ::= object_declaration 5 basic_declaration ::= number_declaration 6 basic_declaration ::= type_declaration 7 basic_declaration ::= subtype_declaration 8 basic_declaration ::= subprogram_declaration 9 basic_declaration ::= package_declaration 10 basic_declaration ::= task_declaration 11 basic_declaration ::= generic_declaration 12 basic_declaration ::= exception_declaration 13 basic_declaration ::= generic_instantiation 14 basic_declaration ::= renaming_declaration 15 object_declaration ::= identifier_list : subtype_indication [:=expression] ; 16 object_declaration ::= identifier_list : CONSTANT subtype_indication [:=expression] ; 17 object_declaration ::= identifier_list : constrained_array_definition [:=expression] ; 18 object_declaration ::= identifier_list : CONSTANT constrained_array_definition [:=expression] ; 19 number_declaration ::= identifier_list : CONSTANT := expression ; 20 identifier_list ::= identifier {,identifier} 21 type_declaration ::= full_type_declaration 22 type_declaration ::= incomplete_type_declaration 23 type_declaration ::= private_type_declaration 24 full_type_declaration ::= TYPE identifier IS type_definition ; 25 full_type_declaration ::= TYPE identifier ( discriminant_specification {;discriminant_specification} ) IS type_definition ; 26 type_definition ::= enumeration_type_definition 27 type_definition ::= integer_type_definition 28 type_definition ::= real_type_definition 29 type_definition ::= array_type_definition 30 type_definition ::= record_type_definition 31 type_definition ::= access_type_definition 32 type_definition ::= derived_type_definition 33 subtype_declaration ::= SUBTYPE identifier IS subtype_indication ; 34 subtype_indication ::= type_mark 35 subtype_indication ::= type_mark constraint 36 type_mark ::= type_name|subtype_name 37 constraint ::= range_constraint 38 constraint ::= floating_point_constraint 39 constraint ::= fixed_point_constraint 40 constraint ::= ( general_component_associations ) 41 derived_type_definition ::= NEW subtype_indication 42 range_constraint ::= RANGE simple_expression 43 range_constraint ::= RANGE simple_expression .. simple_expression 44 enumeration_type_definition ::= ( enumeration_literal_specification {,enumeration_literal_specification} ) 45 enumeration_literal_specification ::= enumeration_literal 46 enumeration_literal ::= identifier 47 enumeration_literal ::= character_literal 48 integer_type_definition ::= range_constraint 49 real_type_definition ::= floating_point_constraint 50 real_type_definition ::= fixed_point_constraint 51 floating_point_constraint ::= floating_accuracy_definition [range_constraint] 52 floating_accuracy_definition ::= DIGITS simple_expression 53 fixed_point_constraint ::= fixed_accuracy_definition [range_constraint] 54 fixed_accuracy_definition ::= DELTA simple_expression 55 array_type_definition ::= unconstrained_array_definition 56 array_type_definition ::= constrained_array_definition 57 unconstrained_array_definition ::= ARRAY ( index_subtype_definition {,index_subtype_definition} ) OF subtype_indication 58 constrained_array_definition ::= ARRAY index_constraint OF subtype_indication 59 index_subtype_definition ::= name RANGE <> 60 index_constraint ::= ( discrete_range {,discrete_range} ) 61 discrete_range ::= name range_constraint 62 discrete_range ::= range 63 range ::= simple_expression 64 range ::= simple_expression .. simple_expression 65 record_type_definition ::= RECORD component_list END RECORD 66 component_list ::= {pragma_decl} {component_declaration} component_declaration {pragma_decl} 67 component_list ::= {pragma_decl} {component_declaration} variant_part {pragma_decl} 68 component_list ::= NULL ; {pragma_decl} 69 component_declaration ::= identifier_list : subtype_indication [:=expression] ; 70 discriminant_specification ::= identifier_list : type_mark [:=expression] 71 variant_part ::= CASE identifier IS {pragma_variant} variant {variant} END CASE ; 72 variant ::= WHEN choice {|choice} => component_list 73 variant ::= WHEN OTHERS => component_list 74 choice ::= simple_expression 75 choice ::= simple_expression .. simple_expression 76 choice ::= name range_constraint 77 access_type_definition ::= ACCESS subtype_indication 78 incomplete_type_declaration ::= TYPE identifier ; 79 incomplete_type_declaration ::= TYPE identifier ( discriminant_specification {;discriminant_specification} ) ; 80 declarative_part ::= {basic_declarative_item} 81 declarative_part ::= {basic_declarative_item} body {later_declarative_item } 82 basic_declarative_item ::= basic_declaration 83 basic_declarative_item ::= representation_clause 84 basic_declarative_item ::= use_clause 85 later_declarative_item ::= body 86 later_declarative_item ::= subprogram_declaration 87 later_declarative_item ::= package_declaration 88 later_declarative_item ::= task_declaration 89 later_declarative_item ::= generic_declaration 90 later_declarative_item ::= use_clause 91 later_declarative_item ::= generic_instantiation 92 body ::= proper_body 93 body ::= body_stub 94 proper_body ::= subprogram_body 95 proper_body ::= package_body 96 proper_body ::= task_body 97 name ::= identifier 98 name ::= character_literal 99 name ::= string_literal 100 name ::= indexed_component 101 name ::= selected_component 102 name ::= attribute 103 indexed_component ::= name ( general_component_associations ) 104 selected_component ::= name . selector 105 selected_component ::= name . ALL 106 selector ::= identifier 107 selector ::= character_literal 108 selector ::= string_literal 109 attribute ::= name ' attribute_designator 110 attribute_designator ::= identifier 111 attribute_designator ::= DIGITS 112 attribute_designator ::= DELTA 113 attribute_designator ::= RANGE 114 aggregate ::= ( component_associations ) 115 component_associations ::= expression,expression{,expression} [,others=>expression] 116 component_associations ::= expression,expression{,expression} , choice{|choice}=>expression {,choice{|choice}=>expression} [,others=>expression] 117 component_associations ::= expression , choice{|choice}=>expression {,choice{|choice}=>expression} [,others=>expression] 118 component_associations ::= choice{|choice}=>expression {,choice{|choice}=>expression} [,others=>expression] 119 component_associations ::= expression , others=>expression 120 component_associations ::= others=>expression 121 general_component_associations ::= ga_expression{,ga_expression} 122 general_component_associations ::= ga_expression{,ga_expression} , identifier{|identifier}=>expression {,identifier{|identifier}=>expression} 123 general_component_associations ::= identifier{|identifier}=>expression {,identifier{|identifier}=>expression} 124 expression ::= relation 125 expression ::= relation{AND__relation} 126 expression ::= relation{OR__relation} 127 expression ::= relation{XOR__relation} 128 expression ::= relation{AND__THEN__relation} 129 expression ::= relation{OR__ELSE__relation} 130 relation ::= simple_expression [relational_operator__simple_expression] 131 relation ::= simple_expression [NOT]IN range 132 simple_expression ::= [unary_adding_operator]term{binary_adding_operator__term} 133 term ::= factor{multiplying_operator__factor} 134 factor ::= primary [exponentiating_operator__primary] 135 factor ::= high_precedence_unary_operator primary 136 parenthesized_expression ::= ( expression ) 137 primary ::= numeric_literal 138 primary ::= NULL 139 primary ::= name 140 primary ::= allocator 141 primary ::= qualified_expression 142 primary ::= aggregate 143 primary ::= parenthesized_expression 144 relational_operator ::= = 145 relational_operator ::= /= 146 relational_operator ::= < 147 relational_operator ::= <= 148 relational_operator ::= > 149 relational_operator ::= >= 150 binary_adding_operator ::= + 151 binary_adding_operator ::= - 152 binary_adding_operator ::= & 153 unary_adding_operator ::= + 154 unary_adding_operator ::= - 155 high_precedence_unary_operator ::= ABS 156 high_precedence_unary_operator ::= NOT 157 multiplying_operator ::= * 158 multiplying_operator ::= / 159 multiplying_operator ::= MOD 160 multiplying_operator ::= REM 161 exponentiating_operator ::= ** 162 qualified_expression ::= name ' aggregate 163 qualified_expression ::= name ' parenthesized_expression 164 allocator ::= NEW type_mark 165 allocator ::= NEW type_mark ( general_component_associations ) 166 allocator ::= NEW expanded_name ' parenthesized_expression 167 allocator ::= NEW expanded_name ' aggregate 168 sequence_of_statements ::= {pragma_stm} statement {statement} 169 statement ::= simple_statement 170 statement ::= compound_statement 171 statement ::= {label}+ simple_statement 172 statement ::= {label}+ compound_statement 173 simple_statement ::= null_statement 174 simple_statement ::= assignment_statement 175 simple_statement ::= exit_statement 176 simple_statement ::= return_statement 177 simple_statement ::= goto_statement 178 simple_statement ::= delay_statement 179 simple_statement ::= abort_statement 180 simple_statement ::= raise_statement 181 simple_statement ::= code_statement 182 simple_statement ::= call_statement 183 compound_statement ::= if_statement 184 compound_statement ::= case_statement 185 compound_statement ::= loop_statement 186 compound_statement ::= block_statement 187 compound_statement ::= accept_statement 188 compound_statement ::= select_statement 189 label ::= << identifier >> 190 null_statement ::= NULL ; 191 assignment_statement ::= name := expression ; 192 if_statement ::= IF condition_THEN__sequence_of_statements {ELSIF__condition__THEN__sequence_of_statements} [ELSE__sequence_of_statements] END IF ; 193 condition ::= expression 194 case_statement ::= CASE expression IS {pragma_alt} case_statement_alternative {case_statement_alternative} END CASE ; 195 case_statement_alternative ::= WHEN choice {|choice} => sequence_of_statements 196 case_statement_alternative ::= WHEN OTHERS => sequence_of_statements 197 loop_statement ::= [loop_identifier:] LOOP sequence_of_statements END LOOP [identifier] ; 198 loop_statement ::= [loop_identifier:] iteration_rule LOOP sequence_of_statements END LOOP [identifier] ; 199 iteration_rule ::= WHILE condition 200 iteration_rule ::= FOR identifier IN discrete_range 201 iteration_rule ::= FOR identifier IN REVERSE discrete_range 202 declarative_part__begin_end_block ::= declarative_part begin_end_block 203 begin_end_block ::= BEGIN sequence_of_statements END 204 begin_end_block ::= BEGIN sequence_of_statements EXCEPTION {pragma_alt}__exception_handler_list END 205 block_statement ::= [block_identifier:] DECLARE declarative_part__begin_end_block [identifier] ; 206 block_statement ::= [block_identifier:] begin_end_block [identifier] ; 207 exit_statement ::= EXIT ; 208 exit_statement ::= EXIT WHEN condition ; 209 exit_statement ::= EXIT expanded_name ; 210 exit_statement ::= EXIT expanded_name WHEN condition ; 211 return_statement ::= RETURN ; 212 return_statement ::= RETURN expression ; 213 goto_statement ::= GOTO expanded_name ; 214 subprogram_declaration ::= subprogram_specification ; 215 subprogram_specification ::= PROCEDURE unit_identifier 216 subprogram_specification ::= PROCEDURE unit_identifier ( parameter_specification {;parameter_specification} ) 217 subprogram_specification ::= FUNCTION designator RETURN type_mark 218 subprogram_specification ::= FUNCTION designator ( parameter_specification {;parameter_specification} ) RETURN type_mark 219 unit_identifier ::= identifier 220 designator ::= identifier 221 designator ::= string_literal 222 parameter_specification ::= identifier_list mode type_mark [:=expression] 223 mode ::= generic_parameter_mode 224 mode ::= : OUT 225 generic_parameter_mode ::= : 226 generic_parameter_mode ::= : IN 227 generic_parameter_mode ::= : IN OUT 228 subprogram_body ::= subprogram_specification IS declarative_part__begin_end_block [end_designator] ; 229 call_statement ::= name ; 230 package_declaration ::= package_specification ; 231 package_specification ::= package__unit_identifier IS {basic_declarative_item} END [identifier] 232 package_specification ::= package__unit_identifier IS {basic_declarative_item} PRIVATE {basic_declarative_item} END [identifier] 233 package_body ::= package__body__unit_identifier IS declarative_part END [identifier] ; 234 package_body ::= package__body__unit_identifier IS declarative_part__begin_end_block [identifier] ; 235 package__unit_identifier ::= PACKAGE unit_identifier 236 package__body__unit_identifier ::= PACKAGE BODY unit_identifier 237 private_type_declaration ::= TYPE identifier IS LIMITED PRIVATE ; 238 private_type_declaration ::= TYPE identifier ( discriminant_specification {;discriminant_specification} ) IS LIMITED PRIVATE ; 239 private_type_declaration ::= TYPE identifier IS PRIVATE ; 240 private_type_declaration ::= TYPE identifier ( discriminant_specification {;discriminant_specification} ) IS PRIVATE ; 241 use_clause ::= USE expanded_name {,expanded_name} ; 242 renaming_declaration ::= identifier_list : type_mark RENAMES name ; 243 renaming_declaration ::= identifier_list : EXCEPTION RENAMES expanded_name ; 244 renaming_declaration ::= PACKAGE identifier RENAMES expanded_name ; 245 renaming_declaration ::= subprogram_specification RENAMES name ; 246 task_declaration ::= task_specification ; 247 task_specification ::= TASK identifier 248 task_specification ::= TASK TYPE identifier 249 task_specification ::= TASK identifier IS {entry_declaration} {representation_clause} END [identifier] 250 task_specification ::= TASK TYPE identifier IS {entry_declaration} {representation_clause} END [identifier] 251 task_body ::= TASK BODY unit_identifier IS declarative_part__begin_end_block [identifier] ; 252 entry_declaration ::= ENTRY identifier [(discrete_range)][formal_part] ; 253 accept_statement ::= ACCEPT identifier [(expression)][formal_part] ; 254 accept_statement ::= ACCEPT identifier [(expression)][formal_part] DO sequence_of_statements END [identifier] ; 255 delay_statement ::= DELAY simple_expression ; 256 select_statement ::= selective_wait 257 select_statement ::= conditional_entry_call 258 select_statement ::= timed_entry_call 259 selective_wait ::= SELECT select_alternative {OR__select_alternative} [ELSE__sequence_of_statements] END SELECT ; 260 select_alternative ::= {pragma_stm} WHEN condition => selective_wait_alternative 261 select_alternative ::= {pragma_stm} selective_wait_alternative 262 selective_wait_alternative ::= accept_alternative 263 selective_wait_alternative ::= delay_alternative 264 selective_wait_alternative ::= terminate_alternative 265 accept_alternative ::= accept_statement [sequence_of_statements] 266 delay_alternative ::= delay_statement [sequence_of_statements] 267 terminate_alternative ::= TERMINATE ; {pragma_stm} 268 conditional_entry_call ::= SELECT {pragma_stm} call_statement [sequence_of_statements] ELSE sequence_of_statements END SELECT ; 269 timed_entry_call ::= SELECT {pragma_stm} call_statement [sequence_of_statements] OR {pragma_stm} delay_alternative END SELECT ; 270 abort_statement ::= ABORT name {,name} ; 271 compilation ::= {compilation_unit} 272 pragma_header ::= PRAGMA pragma_id 273 compilation_unit ::= pragma_header ( general_component_associations ) ; 274 compilation_unit ::= pragma_header ; 275 compilation_unit ::= context_clause library_or_secondary_unit 276 library_or_secondary_unit ::= subprogram_declaration 277 library_or_secondary_unit ::= package_declaration 278 library_or_secondary_unit ::= generic_declaration 279 library_or_secondary_unit ::= generic_instantiation 280 library_or_secondary_unit ::= subprogram_body 281 library_or_secondary_unit ::= package_body 282 library_or_secondary_unit ::= subunit 283 context_clause ::= {with_clause{use_clause}} 284 with_clause ::= WITH with_id {,with_id_list} ; 285 with_id ::= identifier 286 {,with_id_list} ::= EMPTY 287 {,with_id_list} ::= {,with_id_list} , with_id 288 body_stub ::= subprogram_specification IS SEPARATE ; 289 body_stub ::= package__body__unit_identifier IS SEPARATE ; 290 body_stub ::= TASK BODY unit_identifier IS SEPARATE ; 291 subunit ::= SEPARATE ( body_name ) proper_body 292 exception_declaration ::= identifier_list : EXCEPTION ; 293 exception_handler ::= WHEN exception_choice {|exception_choice} => sequence_of_statements 294 exception_choice ::= expanded_name 295 exception_choice ::= OTHERS 296 raise_statement ::= RAISE ; 297 raise_statement ::= RAISE expanded_name ; 298 generic_declaration ::= generic_specification ; 299 generic_specification ::= generic_formal_part subprogram_specification 300 generic_specification ::= generic_formal_part package_specification 301 generic_formal_part ::= GENERIC {generic_parameter_declaration} 302 generic_parameter_declaration ::= identifier_list generic_parameter_mode type_mark [:=expression] ; 303 generic_parameter_declaration ::= TYPE identifier IS generic_type_definition ; 304 generic_parameter_declaration ::= TYPE identifier ( discriminant_specification {;discriminant_specification} ) IS generic_type_definition ; 305 generic_parameter_declaration ::= WITH subprogram_specification [IS__name__or__<>] ; 306 generic_type_definition ::= ( <> ) 307 generic_type_definition ::= RANGE <> 308 generic_type_definition ::= DIGITS <> 309 generic_type_definition ::= DELTA <> 310 generic_type_definition ::= LIMITED PRIVATE 311 generic_type_definition ::= PRIVATE 312 generic_type_definition ::= array_type_definition 313 generic_type_definition ::= access_type_definition 314 generic_instantiation ::= package__unit_identifier IS NEW generic_name ; 315 generic_instantiation ::= package__unit_identifier IS NEW generic_name ( generic_association {,generic_association} ) ; 316 generic_instantiation ::= FUNCTION designator IS NEW generic_name ; 317 generic_instantiation ::= FUNCTION designator IS NEW generic_name ( generic_association {,generic_association} ) ; 318 generic_instantiation ::= subprogram_specification IS NEW generic_name ; 319 generic_instantiation ::= subprogram_specification IS NEW generic_name ( generic_association {,generic_association} ) ; 320 generic_association ::= [generic_formal_parameter=>]generic_actual_parameter 321 generic_formal_parameter ::= identifier 322 generic_formal_parameter ::= string_literal 323 generic_actual_parameter ::= expression 324 representation_clause ::= length_clause 325 representation_clause ::= enumeration_representation_clause 326 representation_clause ::= address_clause 327 representation_clause ::= record_representation_clause 328 length_clause ::= FOR attribute USE simple_expression ; 329 enumeration_representation_clause ::= FOR identifier USE aggregate ; 330 record_representation_clause ::= FOR identifier USE RECORD {component_clause} END RECORD ; 331 record_representation_clause ::= FOR identifier USE RECORD alignment_claus e {component_clause} END RECORD ; 332 component_clause ::= name AT simple_expression range_constraint ; 333 alignment_clause ::= AT MOD simple_expression ; 334 address_clause ::= FOR identifier USE AT simple_expression ; 335 code_statement ::= name ' aggregate ; 336 {pragma_decl} ::= EMPTY 337 {pragma_decl} ::= {pragma_decl} pragma 338 {pragma_variant} ::= EMPTY 339 {pragma_variant} ::= {pragma_variant} pragma 340 {pragma_stm} ::= EMPTY 341 {pragma_stm} ::= {pragma_stm} pragma 342 {pragma_alt} ::= EMPTY 343 {pragma_alt} ::= {pragma_alt} pragma 344 [:=expression] ::= EMPTY 345 [:=expression] ::= := expression 346 {,identifier} ::= EMPTY 347 {,identifier} ::= {,identifier} , identifier 348 type_name|subtype_name ::= expanded_name 349 expanded_name ::= identifier 350 expanded_name ::= expanded_name . identifier 351 body_name ::= identifier 352 body_name ::= body_name . identifier 353 generic_name ::= identifier 354 generic_name ::= generic_name . identifier 355 {,enumeration_literal_specification} ::= EMPTY 356 {,enumeration_literal_specification} ::= {,enumeration_literal_specification} , enumeration_literal_specification 357 [range_constraint] ::= EMPTY 358 [range_constraint] ::= range_constraint 359 {,index_subtype_definition} ::= EMPTY 360 {,index_subtype_definition} ::= {,index_subtype_definition} , index_subtype_definition 361 {,discrete_range} ::= EMPTY 362 {,discrete_range} ::= {,discrete_range} , discrete_range 363 {component_declaration} ::= EMPTY 364 {component_declaration} ::= {component_declaration} component_declaration {pragma_decl} 365 {;discriminant_specification} ::= EMPTY 366 {;discriminant_specification} ::= {;discriminant_specification} ; discriminant_specification 367 {variant} ::= EMPTY 368 {variant} ::= {variant} variant 369 {|choice} ::= EMPTY 370 {|choice} ::= {|choice} '|' choice 371 {basic_declarative_item} ::= {pragma_decl} 372 {basic_declarative_item} ::= {basic_declarative_item} basic_declarative_item {pragma_decl} 373 {later_declarative_item} ::= {pragma_decl} 374 {later_declarative_item} ::= {later_declarative_item} later_declarative_item {pragma_decl} 375 expression,expression{,expression} ::= expression , expression 376 expression,expression{,expression} ::= expression,expression{,expression} , expression 377 choice{|choice}=>expression ::= choice {|choice} => expression 378 {,choice{|choice}=>expression} ::= EMPTY 379 {,choice{|choice}=>expression} ::= {,choice{|choice}=>expression} , choice{|choice}=>expression 380 [,others=>expression] ::= EMPTY 381 [,others=>expression] ::= , others=>expression 382 others=>expression ::= OTHERS => expression 383 ga_expression ::= expression 384 ga_expression ::= simple_expression .. simple_expression 385 ga_expression ::= name range_constraint 386 ga_expression{,ga_expression} ::= ga_expression 387 ga_expression{,ga_expression} ::= ga_expression{,ga_expression} , ga_expression 388 identifier{|identifier}=>expression ::= identifier {|identifier} => expression 389 {,identifier{|identifier}=>expression} ::= EMPTY 390 {,identifier{|identifier}=>expression} ::= {,identifier{|identifier}=>expression} , identifier{|identifier}=>expression 391 {|identifier} ::= EMPTY 392 {|identifier} ::= {|identifier} '|' identifier 393 relation{AND__relation} ::= relation AND relation 394 relation{AND__relation} ::= relation{AND__relation} AND relation 395 relation{OR__relation} ::= relation OR relation 396 relation{OR__relation} ::= relation{OR__relation} OR relation 397 relation{XOR__relation} ::= relation XOR relation 398 relation{XOR__relation} ::= relation{XOR__relation} XOR relation 399 relation{AND__THEN__relation} ::= relation AND THEN relation 400 relation{AND__THEN__relation} ::= relation{AND__THEN__relation} AND THEN relation 401 relation{OR__ELSE__relation} ::= relation OR ELSE relation 402 relation{OR__ELSE__relation} ::= relation{OR__ELSE__relation} OR ELSE relation 403 [relational_operator__simple_expression] ::= EMPTY 404 [relational_operator__simple_expression] ::= relational_operator simple_expression 405 [NOT]IN ::= IN 406 [NOT]IN ::= NOT IN 407 [unary_adding_operator]term{binary_adding_operator__term} ::= term 408 [unary_adding_operator]term{binary_adding_operator__term} ::= unary_adding_operator term 409 [unary_adding_operator]term{binary_adding_operator__term} ::= [unary_adding_operator]term{binary_adding_operator__term} binary_adding_operator term 410 factor{multiplying_operator__factor} ::= factor 411 factor{multiplying_operator__factor} ::= factor{multiplying_operator__factor} multiplying_operator factor 412 [exponentiating_operator__primary] ::= EMPTY 413 [exponentiating_operator__primary] ::= exponentiating_operator primary 414 {statement} ::= {pragma_stm} 415 {statement} ::= {statement} statement {pragma_stm} 416 {label}+ ::= label 417 {label}+ ::= {label}+ label 418 condition_THEN__sequence_of_statements ::= condition THEN sequence_of_statements 419 {ELSIF__condition__THEN__sequence_of_statements} ::= EMPTY 420 {ELSIF__condition__THEN__sequence_of_statements} ::= {ELSIF__condition__THEN__sequence_of_statements} ELSIF condition THEN sequence_of_statements 421 [ELSE__sequence_of_statements] ::= EMPTY 422 [ELSE__sequence_of_statements] ::= ELSE sequence_of_statements 423 {case_statement_alternative} ::= EMPTY 424 {case_statement_alternative} ::= {case_statement_alternative} case_statement_alternative 425 [loop_identifier:] ::= EMPTY 426 [loop_identifier:] ::= identifier : 427 [identifier] ::= EMPTY 428 [identifier] ::= identifier 429 [block_identifier:] ::= EMPTY 430 [block_identifier:] ::= identifier : 431 {pragma_alt}__exception_handler_list ::= {pragma_alt} exception_handler_list 432 exception_handler_list ::= exception_handler 433 exception_handler_list ::= exception_handler_list exception_handler 434 {;parameter_specification} ::= EMPTY 435 {;parameter_specification} ::= {;parameter_specification} ; parameter_specification 436 [end_designator] ::= EMPTY 437 [end_designator] ::= identifier 438 [end_designator] ::= string_literal 439 {,expanded_name} ::= EMPTY 440 {,expanded_name} ::= {,expanded_name} , expanded_name 441 {entry_declaration} ::= {pragma_decl} 442 {entry_declaration} ::= {entry_declaration} entry_declaration {pragma_decl } 443 {representation_clause} ::= EMPTY 444 {representation_clause} ::= {representation_clause} representation_clause {pragma_decl} 445 [(discrete_range)][formal_part] ::= EMPTY 446 [(discrete_range)][formal_part] ::= ( parameter_specification {;parameter_specification} ) 447 [(discrete_range)][formal_part] ::= ( discrete_range ) 448 [(discrete_range)][formal_part] ::= ( discrete_range ) ( parameter_specification {;parameter_specification} ) 449 [(expression)][formal_part] ::= EMPTY 450 [(expression)][formal_part] ::= ( parameter_specification {;parameter_specification} ) 451 [(expression)][formal_part] ::= ( expression ) 452 [(expression)][formal_part] ::= ( expression ) ( parameter_specification {;parameter_specification} ) 453 {OR__select_alternative} ::= EMPTY 454 {OR__select_alternative} ::= {OR__select_alternative} OR select_alternativ e 455 [sequence_of_statements] ::= {pragma_stm} 456 [sequence_of_statements] ::= sequence_of_statements 457 {,name} ::= EMPTY 458 {,name} ::= {,name} , name 459 {compilation_unit} ::= compilation_unit 460 {compilation_unit} ::= {compilation_unit} compilation_unit 461 {with_clause{use_clause}} ::= EMPTY 462 {with_clause{use_clause}} ::= {with_clause{use_clause}} with_clause use_clause_list 463 use_clause_list ::= {pragma_decl} 464 use_clause_list ::= use_clause_list use_clause {pragma_decl} 465 {|exception_choice} ::= EMPTY 466 {|exception_choice} ::= {|exception_choice} '|' exception_choice 467 {generic_parameter_declaration} ::= EMPTY 468 {generic_parameter_declaration} ::= {generic_parameter_declaration} generic_parameter_declaration 469 [IS__name__or__<>] ::= EMPTY 470 [IS__name__or__<>] ::= IS name 471 [IS__name__or__<>] ::= IS <> 472 {,generic_association} ::= EMPTY 473 {,generic_association} ::= {,generic_association} , generic_association 474 [generic_formal_parameter=>]generic_actual_parameter ::= generic_actual_parameter 475 [generic_formal_parameter=>]generic_actual_parameter ::= generic_formal_parameter => generic_actual_parameter 476 {component_clause} ::= {pragma_decl} 477 {component_clause} ::= {component_clause} component_clause {pragma_decl} Non terminalss $ACC compilation pragma_id general_component_associations pragma object_declaration basic_declaration number_declaration type_declaration subtype_declaration subprogram_declaration package_declaration task_declaration generic_declaration exception_declaration generic_instantiation renaming_declaration identifier_list subtype_indication [:=expression] constrained_array_definition expression {,identifier} full_type_declaration incomplete_type_declaration private_type_declaration type_definition discriminant_specification {;discriminant_specification} enumeration_type_definition integer_type_definition real_type_definition array_type_definition record_type_definition access_type_definition derived_type_definition type_mark constraint type_name|subtype_name range_constraint floating_point_constraint fixed_point_constraint simple_expression enumeration_literal_specification {,enumeration_literal_specification} enumeration_literal floating_accuracy_definition [range_constraint] fixed_accuracy_definition unconstrained_array_definition index_subtype_definition {,index_subtype_definition} index_constraint name discrete_range {,discrete_range} range component_list {pragma_decl} {component_declaration} component_declaration variant_part {pragma_variant} variant {variant} choice {|choice} {basic_declarative_item} declarative_part body {later_declarative_item} basic_declarative_item representation_clause use_clause later_declarative_item proper_body body_stub subprogram_body package_body task_body indexed_component selected_component attribute selector attribute_designator component_associations aggregate expression,expression{,expression} [,others=>expression] choice{|choice}=>expression {,choice{|choice}=>expression} others=>expression ga_expression{,ga_expression} identifier{|identifier}=>expression {,identifier{|identifier}=>expression} relation relation{AND__relation} relation{OR__relation} relation{XOR__relation} relation{AND__THEN__relation} relation{OR__ELSE__relation} [relational_operator__simple_expression] [NOT]IN [unary_adding_operator]term{binary_adding_operator__term} factor{multiplying_operator__factor} term primary [exponentiating_operator__primary] factor high_precedence_unary_operator parenthesized_expression allocator qualified_expression relational_operator binary_adding_operator unary_adding_operator multiplying_operator exponentiating_operator expanded_name {pragma_stm} statement {statement} sequence_of_statements simple_statement compound_statement {label}+ null_statement assignment_statement exit_statement return_statement goto_statement delay_statement abort_statement raise_statement code_statement call_statement if_statement case_statement loop_statement block_statement accept_statement select_statement label condition_THEN__sequence_of_statements {ELSIF__condition__THEN__sequence_of_statements} [ELSE__sequence_of_statements] condition {pragma_alt} case_statement_alternative {case_statement_alternative} [loop_identifier:] [identifier] iteration_rule begin_end_block declarative_part__begin_end_block {pragma_alt}__exception_handler_list [block_identifier:] subprogram_specification unit_identifier parameter_specification {;parameter_specification} designator mode generic_parameter_mode [end_designator] package_specification package__unit_identifier package__body__unit_identifier {,expanded_name} task_specification {entry_declaration} {representation_clause} [(discrete_range)][formal_part] entry_declaration [(expression)][formal_part] selective_wait conditional_entry_call timed_entry_call select_alternative {OR__select_alternative} selective_wait_alternative accept_alternative delay_alternative terminate_alternative [sequence_of_statements] {,name} {compilation_unit} pragma_header compilation_unit context_clause library_or_secondary_unit subunit {with_clause{use_clause}} with_id {,with_id_list} with_clause body_name exception_choice {|exception_choice} exception_handler generic_specification generic_formal_part {generic_parameter_declaration} generic_parameter_declaration generic_type_definition [IS__name__or__<>] generic_name generic_association {,generic_association} [generic_formal_parameter=>]generic_actual_parameter generic_formal_parameter generic_actual_parameter length_clause enumeration_representation_clause address_clause record_representation_clause {component_clause} alignment_clause component_clause ga_expression {|identifier} exception_handler_list use_clause_list Information about Action Tables Number of Entries 3862 Origin Table Size 5519 Action Table Size 8225 Number Unused 2685 Distribution of entries 1995 678 134 26 1 0 0 0 Timing Statistics Cpu Time Elapsed LG Reads LG Writes Parse: 147 11975 0 144 Preliminary: 175 499 0 296 First Map: 46 2428 0 25 Item Creation: 27 1564 0 40 Follow Map: 13 1314 0 0 Closure: 11 1296 0 0 States: 1514 14222 93 2263 Reductions: 9384 19704 3833 2589 Summary: 80 1932 39 0 Compress: 2901 5393 1500 950 Table Dump: 165 3448 240 5 --:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: --compord.cnt --:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: [NOSC.RELEASES.V0101.COMPORD.SOURCE]UNITDAG.SPC 34 44 [NOSC.RELEASES.V0101.COMPORD.SOURCE]MINIDAG.SPC 15 9 [NOSC.RELEASES.V0101.COMPORD.SOURCE]COPKG.DAT 77 94 [NOSC.RELEASES.V0101.COMPORD.SOURCE]COMPORD.SPC 13 55 [NOSC.RELEASES.V0101.COMPORD.SOURCE]CDRIVER.ADA 370 243 [NOSC.RELEASES.V0101.COMPORD.SOURCE]REPORT.SPC 6 56 [NOSC.RELEASES.V0101.COMPORD.SOURCE]LOOKUP.SPC 12 46 [NOSC.RELEASES.V0101.COMPORD.SOURCE]COMPORD.BDY 353 367 [NOSC.RELEASES.V0101.COMPORD.SOURCE]GRMCONST.BDY 32 31 [NOSC.RELEASES.V0101.COMPORD.SOURCE]PTBLS.BDY 31758 3529 [NOSC.RELEASES.V0101.COMPORD.SOURCE]REPORT.BDY 689 576 [NOSC.RELEASES.V0101.COMPORD.SOURCE]LOOKUP.BDY 113 87 [NOSC.RELEASES.V0101.COMPORD.SOURCE]CMPUTIL.SPC 6 114 [NOSC.RELEASES.V0101.COMPORD.SOURCE]CMPUTIL.BDY 512 539 [NOSC.RELEASES.V0101.COMPORD.SOURCE]APPLYACT.SUB 40 306 [NOSC.RELEASES.V0101.COMPORD.SOURCE]GETNEXT.SUB 16 22