Programmer's ROM - The Computer Language Library

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

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

Wrap

Text File | 1988-05-03 | 67.2 KB | 2,298 lines

--:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: --read.me --:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: To build the statement profile tool: 1. Compile all the abstractions into a program library (see READ.ME in abstractions directory for details) 2. Compile everything named in the STMTPROF.CO file into the program library containing the abstractions or a sublibrary whose parent library contains all the abstractions. STMTPROF.CO lists file names in the correct compilation order. 3. Link STMTPROF with the program library where everything was compiled. To do this using the DEC Ada compiler type: $ acs link stmtprof To run the tool on VMS: 1. Define a logical symbol for the executable of STMTPROF. For example, STMTPROF :== $DRB1:[NOSC.TOOLS.STMTPROF]STMTPROF.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. For example, STMTPROF (SOURCE=>"test.ada", OUTPUT=>"test.out"); Entering the command STMTPROF with no parameters gives a brief description of how to use the tool. Files contained in this directory: STMTPROF.CO -- Compilation order for statement profile sources STMTPROF.EXE -- VMS 4.0 statement profile executable The [.SOURCE] subdirectory contains most of the sources that make up the statement profile tool. Other sources are contained in the abstractions directory. Files in [.SOURCE]: The source files which make up the statement profile tool are as follows: STMTPROF.ADA -- the driver which deals with the command line SPUTILS.SPC -- the procedures which control gathering info and reporting SPUTILS.BDY Most of the sources for the parser which the statement profile tool uses are in the abstractions directory. The four units which are unique to this tool are as follows: APPLYACT.SUB -- A subunit of the parser which calls the action subprograms GETNEXT.SUB -- A subunit of the lexer which returns non-comment tokens to the lexer and buffers comments GRMCONST.BDY -- Grammar constants for the parse tables PTBLS.BDY -- The parse tables. The ACVC A tests were used in testing the statement profile tool. The [.DOC] subdirectory contains the documentation for the statement profile tool. Files in [.DOC]: USERMAN.MEM -- Statement profile user's manual USERMAN.RNO -- Runoff input for user's manual STMTGRM.LIS -- Listing of statement profile grammar. The rule numbers in this file may be used to make changes to the case statement in the Apply_Actions subunit. STMTPROF.CNT-- Statement counts and line counts of statement profile source files. --:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: --userman.mem --:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: STATEMENT PROFILE REPORT _________ _______ ______ _________ _______ ______ 1 STATEMENT PROFILE REPORT ___________ 1.1 Description The Statement Profile Report counts every instance of each of the various types of Ada statements in the given package or subprogram body including comments, distinguishing whole-line comments from comments on a line of code. From these raw counts a series of ratios and percentages can then be computed and represented in a table. The raw count or the table is output to the specified or the default output file. If a package is specified, the package and all subprograms within that package are counted. If a subprogram includes nested subprograms, these are also counted, and a separate report table is produced for each. For each file, a report is also produced for all statements outside any package or subprogram (these are usually with and use statements), and a report containing a total of all statements in the source file. _______ ______ 1.2 Command Format type REPORT_TYPE is (RAW, TABLE); procedure STATEMENT_PROFILE ( SOURCE : in STRING; OUTPUT : in STRING := ""; PROFILE : in STRING := ""; REPORT : in REPORT_TYPE := TABLE ); SOURCE Name of the source file to be profiled for statement types. It should be a names of Ada source code file. (Statement Profile Report assumes that the Ada source code is syntactically correct.) OUTPUT Name of the output file for the report. If not specified defaults to standard output. PROFILE Specifies a ratio of statement types as "stmttype,...,stmttype : stmttype,...,stmttype" If not specified no ratio calculations are performed. REPORT Specifies the report output format as RAW or TABLE. If not specified defaults to TABLE. Before execution the command line is echoed to the output stream defined by the system for error messages (normally the terminal). If the statement profile is invoked as: STATEMENT_PROFILE ( "TEST.ADA", "TEST.RPT"); The command line will be echoed as: STATEMENT_PROFILE ( SOURCE => "TEST.ADA", OUTPUT => "TEST.RPT", PROFILE => "", REPORT => ); Page 2 _________ _____ 1.3 Statement Types The following is a list of the recognised statement types: stmt_type name LRM Syntax Summary 1. ABORT_STMT abort_statement 5.1 2. ACCEPT_STMT accept_statement 5.1 3. ASSIGNMENT_STMT assignment_statement 5.2 4. BASIC_DECL basic_declaration 3.1 5. BLOCK_STMT block_statement 5.6 6. CASE_STMT case_statement 5.4 7. CODE_STMT code_statement 5.1 8. DELAY_STMT delay_statement 5.1 9. ELSE_STMT else part 5.3 10. ELSIF_STMT else part with if 5.3 11. ENTRY_CALL entry_call_statement 5.1 12. EXCEPT_HANDLER exception_handler 11.2 13. EXIT_STMT exit_statement 5.7 14. GOTO_STMT goto_statement 5.9 15. IF_STMT if_statement 5.3 16. LONG_COMMENT whole-line comment 17. LOOP_STMT loop_statement 5.5 18. NULL_STMT null_statement 5.1 19. PRAGMA_STMT pragma 2.6 20. PROCEDURE_CALL procedure_call_statement 5.1 21. RAISE_STMT raise_statement 5.1 22. RETURN_STMT return_statement 5.8 23. SELECT_STMT select_statement 5.1 24. SHORT_COMMENT comment on a line of code 25. USE_STMT use_clauses 8.4 26. WITH_STMT with_clauses 10.1 Statement types for the profile spec include the above types and the keyword ALLSTMTS. The ALLSTMTS keyword allows for a comparison of a collection of statement types with the total number of statements. Page 3 ___ ______ 1.4 Raw Format REPORT => RAW generates an output of the raw counts so that the user can do his/her own calculations and/or formatting. Given the input line: STATEMENT_PROFILE ( SOURCE => "STMTPROF.ADA", OUTPUT => "STMTPROF.RAW", REPORT => RAW ); The result of the statement report tools found in the file STMTPROF.RAW is: STMTPROF.ADA StmtProf 0 0 10 15 1 0 0 0 1 0 0 12 0 0 5 0 2 0 0 67 0 4 0 1 1 0 0 0 119 STMTPROF.ADA 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 1 0 10 0 0 14 <TOTAL> STMTPROF.ADA 0 0 10 16 1 0 0 0 1 0 0 12 0 0 5 2 2 0 0 67 0 4 0 2 1 10 0 0 133 The report consists of one line of raw count for each package or subprogram in canonical order. Page 4 _____ ______ 1.5 Table Format Given the input line: STATEMENT_PROFILE ( SOURCE => "STMTPROF.ADA", OUTPUT => "STMTPROF.TBL", PROFILE => "IF_STMT : ELSIF_STMT, ELSE_STMT" ); The result of the statement report tools found in the file STMTPROF.TBL is: -------------------------------------------------------------------------- Name = STMTPROF.ADA StmtProf -------------------------------------------------------------------------- Statement # % group1 group2 graph -------------------------------------------------------------------------- ABORT_STMT 0 0 | ACCEPT_STMT 0 0 | ASSIGNMENT_STMT 10 8 |== BASIC_DECL 15 12 |=== BLOCK_STMT 1 0 | CASE_STMT 0 0 | CODE_STMT 0 0 | DELAY_STMT 0 0 | ELSE_STMT 1 0 * | ELSIF_STMT 0 0 * | ENTRY_CALL 0 0 | EXCEPT_HANDLER 12 10 |== EXIT_STMT 0 0 | GOTO_STMT 0 0 | IF_STMT 5 4 * |= LONG_COMMENT 0 0 | LOOP_STMT 2 1 | NULL_STMT 0 0 | PRAGMA_STMT 0 0 | PROCEDURE_CALL 67 56 |============== RAISE_STMT 0 0 | RETURN_STMT 4 3 | SELECT_STMT 0 0 | SHORT_COMMENT 1 0 | USE_STMT 1 0 | WITH_STMT 0 0 | -------------------------------------------------------------------------- TOTALS 119 5 1 -------------------------------------------------------------------------- sum group1 + group2 = 6 ratio group1:group2 = 500 / 100 -------------------------------------------------------------------------- Page 5 -------------------------------------------------------------------------- Name = STMTPROF.ADA -------------------------------------------------------------------------- Statement # % group1 group2 graph -------------------------------------------------------------------------- ABORT_STMT 0 0 | ACCEPT_STMT 0 0 | ASSIGNMENT_STMT 0 0 | BASIC_DECL 1 7 |= BLOCK_STMT 0 0 | CASE_STMT 0 0 | CODE_STMT 0 0 | DELAY_STMT 0 0 | ELSE_STMT 0 0 * | ELSIF_STMT 0 0 * | ENTRY_CALL 0 0 | EXCEPT_HANDLER 0 0 | EXIT_STMT 0 0 | GOTO_STMT 0 0 | IF_STMT 0 0 * | LONG_COMMENT 2 14 |=== LOOP_STMT 0 0 | NULL_STMT 0 0 | PRAGMA_STMT 0 0 | PROCEDURE_CALL 0 0 | RAISE_STMT 0 0 | RETURN_STMT 0 0 | SELECT_STMT 0 0 | SHORT_COMMENT 1 7 |= USE_STMT 0 0 | WITH_STMT 10 71 |================= -------------------------------------------------------------------------- TOTALS 14 0 0 -------------------------------------------------------------------------- sum group1 + group2 = 0 ratio group1:group2 = 0 / 100 -------------------------------------------------------------------------- Page 6 -------------------------------------------------------------------------- Grand Totals for File -------------------------------------------------------------------------- Name = STMTPROF.ADA -------------------------------------------------------------------------- Statement # % group1 group2 graph -------------------------------------------------------------------------- ABORT_STMT 0 0 | ACCEPT_STMT 0 0 | ASSIGNMENT_STMT 10 7 |= BASIC_DECL 16 12 |=== BLOCK_STMT 1 0 | CASE_STMT 0 0 | CODE_STMT 0 0 | DELAY_STMT 0 0 | ELSE_STMT 1 0 * | ELSIF_STMT 0 0 * | ENTRY_CALL 0 0 | EXCEPT_HANDLER 12 9 |== EXIT_STMT 0 0 | GOTO_STMT 0 0 | IF_STMT 5 3 * | LONG_COMMENT 2 1 | LOOP_STMT 2 1 | NULL_STMT 0 0 | PRAGMA_STMT 0 0 | PROCEDURE_CALL 67 50 |============ RAISE_STMT 0 0 | RETURN_STMT 4 3 | SELECT_STMT 0 0 | SHORT_COMMENT 2 1 | USE_STMT 1 0 | WITH_STMT 10 7 |= -------------------------------------------------------------------------- TOTALS 133 5 1 -------------------------------------------------------------------------- sum group1 + group2 = 6 ratio group1:group2 = 500 / 100 -------------------------------------------------------------------------- Page 7 ____ 1.6 Bugs --:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: --userman.rno --:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: .FLAG BOLD .HEADER LEVEL 1^*^&STATEMENT PROFILE REPORT\&\* .HEADER LEVEL 2^&Description\& .PARAGRAPH The Statement Profile Report counts every instance of each of the various types of Ada statements in the given package or subprogram body including comments, distinguishing whole-line comments from comments on a line of code. From these raw counts a series of ratios and percentages can then be computed and represented in a table. The raw count or the table is output to the specified or the default output file. If a package is specified, the package and all subprograms within that package are counted. If a subprogram includes nested subprograms, these are also counted, and a separate report table is produced for each. For each file, a report is also produced for all statements outside any package or subprogram (these are usually with and use statements), and a report containing a total of all statements in the source file. .HEADER LEVEL 2^&Command Format\& .LITERAL type REPORT_TYPE is (RAW, TABLE); procedure STATEMENT_PROFILE ( SOURCE : in STRING; OUTPUT : in STRING := ""; PROFILE : in STRING := ""; REPORT : in REPORT_TYPE := TABLE ); .END LITERAL .BLANK .LEFT MARGIN 10 .TAB STOP 10 .INDENT -10 SOURCE Name of the source file to be profiled for statement types. It should be a names of Ada source code file. (Statement Profile Report assumes that the Ada source code is syntactically correct.) .INDENT -10 OUTPUT Name of the output file for the report. If not specified defaults to standard output. .INDENT -10 PROFILE Specifies a ratio of statement types as .BREAK "stmt_type,...,stmt_type : stmt_type,...,stmt_type" If not specified no ratio calculations are performed. .INDENT -10 REPORT Specifies the report output format as RAW or TABLE. If not specified defaults to TABLE. .LEFT MARGIN 0 .BLANK 2 Before execution the command line is echoed to the output stream defined by the system for error messages (normally the terminal). If the statement profile is invoked as: .BLANK .LITERAL STATEMENT_PROFILE ( "TEST.ADA", "TEST.RPT"); .END LITERAL .BLANK The command line will be echoed as: .BLANK .LITERAL STATEMENT_PROFILE ( SOURCE => "TEST.ADA", OUTPUT => "TEST.RPT", PROFILE => "", REPORT => ); .END LITERAL .PAGE .HEADER LEVEL 2^&Statement Types\& The following is a list of the recognised statement types: .BLANK .LITERAL stmt_type name LRM Syntax Summary 1. ABORT_STMT abort_statement 5.1 2. ACCEPT_STMT accept_statement 5.1 3. ASSIGNMENT_STMT assignment_statement 5.2 4. BASIC_DECL basic_declaration 3.1 5. BLOCK_STMT block_statement 5.6 6. CASE_STMT case_statement 5.4 7. CODE_STMT code_statement 5.1 8. DELAY_STMT delay_statement 5.1 9. ELSE_STMT else part 5.3 10. ELSIF_STMT else part with if 5.3 11. ENTRY_CALL entry_call_statement 5.1 12. EXCEPT_HANDLER exception_handler 11.2 13. EXIT_STMT exit_statement 5.7 14. GOTO_STMT goto_statement 5.9 15. IF_STMT if_statement 5.3 16. LONG_COMMENT whole-line comment 17. LOOP_STMT loop_statement 5.5 18. NULL_STMT null_statement 5.1 19. PRAGMA_STMT pragma 2.6 20. PROCEDURE_CALL procedure_call_statement 5.1 21. RAISE_STMT raise_statement 5.1 22. RETURN_STMT return_statement 5.8 23. SELECT_STMT select_statement 5.1 24. SHORT_COMMENT comment on a line of code 25. USE_STMT use_clauses 8.4 26. WITH_STMT with_clauses 10.1 .END LITERAL .BLANK Statement types for the profile spec include the above types and the keyword ALLSTMTS. .BLANK The ALLSTMTS keyword allows for a comparison of a collection of statement types with the total number of statements. .BLANK .PAGE .HEADER LEVEL 2^&Raw Format\& REPORT => RAW generates an output of the raw counts so that the user can do his/her own calculations and/or formatting. Given the input line: .BLANK .LITERAL STATEMENT_PROFILE ( SOURCE => "STMTPROF.ADA", OUTPUT => "STMTPROF.RAW", REPORT => RAW ); .END LITERAL .BLANK The result of the statement report tools found in the file STMTPROF.RAW is: .BLANK .LITERAL STMTPROF.ADA StmtProf 0 0 10 15 1 0 0 0 1 0 0 12 0 0 5 0 2 0 0 67 0 4 0 1 1 0 0 0 119 STMTPROF.ADA 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 1 0 10 0 0 14 <TOTAL> STMTPROF.ADA 0 0 10 16 1 0 0 0 1 0 0 12 0 0 5 2 2 0 0 67 0 4 0 2 1 10 0 0 133 .END LITERAL .BLANK The report consists of one line of raw count for each package or subprogram in canonical order. .PAGE .HEADER LEVEL 2^&Table Format\& Given the input line: .BLANK .LITERAL STATEMENT_PROFILE ( SOURCE => "STMTPROF.ADA", OUTPUT => "STMTPROF.TBL", PROFILE => "IF_STMT : ELSIF_STMT, ELSE_STMT" ); .END LITERAL .BLANK The result of the statement report tools found in the file STMTPROF.TBL is: .BLANK .LITERAL -------------------------------------------------------------------------- Name = STMTPROF.ADA StmtProf -------------------------------------------------------------------------- Statement # % group1 group2 graph -------------------------------------------------------------------------- ABORT_STMT 0 0 | ACCEPT_STMT 0 0 | ASSIGNMENT_STMT 10 8 |== BASIC_DECL 15 12 |=== BLOCK_STMT 1 0 | CASE_STMT 0 0 | CODE_STMT 0 0 | DELAY_STMT 0 0 | ELSE_STMT 1 0 * | ELSIF_STMT 0 0 * | ENTRY_CALL 0 0 | EXCEPT_HANDLER 12 10 |== EXIT_STMT 0 0 | GOTO_STMT 0 0 | IF_STMT 5 4 * |= LONG_COMMENT 0 0 | LOOP_STMT 2 1 | NULL_STMT 0 0 | PRAGMA_STMT 0 0 | PROCEDURE_CALL 67 56 |============== RAISE_STMT 0 0 | RETURN_STMT 4 3 | SELECT_STMT 0 0 | SHORT_COMMENT 1 0 | USE_STMT 1 0 | WITH_STMT 0 0 | -------------------------------------------------------------------------- TOTALS 119 5 1 -------------------------------------------------------------------------- sum group1 + group2 = 6 ratio group1:group2 = 500 / 100 -------------------------------------------------------------------------- .END LITERAL .PAGE .LITERAL -------------------------------------------------------------------------- Name = STMTPROF.ADA -------------------------------------------------------------------------- Statement # % group1 group2 graph -------------------------------------------------------------------------- ABORT_STMT 0 0 | ACCEPT_STMT 0 0 | ASSIGNMENT_STMT 0 0 | BASIC_DECL 1 7 |= BLOCK_STMT 0 0 | CASE_STMT 0 0 | CODE_STMT 0 0 | DELAY_STMT 0 0 | ELSE_STMT 0 0 * | ELSIF_STMT 0 0 * | ENTRY_CALL 0 0 | EXCEPT_HANDLER 0 0 | EXIT_STMT 0 0 | GOTO_STMT 0 0 | IF_STMT 0 0 * | LONG_COMMENT 2 14 |=== LOOP_STMT 0 0 | NULL_STMT 0 0 | PRAGMA_STMT 0 0 | PROCEDURE_CALL 0 0 | RAISE_STMT 0 0 | RETURN_STMT 0 0 | SELECT_STMT 0 0 | SHORT_COMMENT 1 7 |= USE_STMT 0 0 | WITH_STMT 10 71 |================= -------------------------------------------------------------------------- TOTALS 14 0 0 -------------------------------------------------------------------------- sum group1 + group2 = 0 ratio group1:group2 = 0 / 100 -------------------------------------------------------------------------- .END LITERAL .PAGE .LITERAL -------------------------------------------------------------------------- Grand Totals for File -------------------------------------------------------------------------- Name = STMTPROF.ADA -------------------------------------------------------------------------- Statement # % group1 group2 graph -------------------------------------------------------------------------- ABORT_STMT 0 0 | ACCEPT_STMT 0 0 | ASSIGNMENT_STMT 10 7 |= BASIC_DECL 16 12 |=== BLOCK_STMT 1 0 | CASE_STMT 0 0 | CODE_STMT 0 0 | DELAY_STMT 0 0 | ELSE_STMT 1 0 * | ELSIF_STMT 0 0 * | ENTRY_CALL 0 0 | EXCEPT_HANDLER 12 9 |== EXIT_STMT 0 0 | GOTO_STMT 0 0 | IF_STMT 5 3 * | LONG_COMMENT 2 1 | LOOP_STMT 2 1 | NULL_STMT 0 0 | PRAGMA_STMT 0 0 | PROCEDURE_CALL 67 50 |============ RAISE_STMT 0 0 | RETURN_STMT 4 3 | SELECT_STMT 0 0 | SHORT_COMMENT 2 1 | USE_STMT 1 0 | WITH_STMT 10 7 |= -------------------------------------------------------------------------- TOTALS 133 5 1 -------------------------------------------------------------------------- sum group1 + group2 = 6 ratio group1:group2 = 500 / 100 -------------------------------------------------------------------------- .END LITERAL .PAGE .HEADER LEVEL 2^&Bugs\& .PAGE --:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: --stmtgrm.lis --:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: 1Options in Effect DEFAULT ACTIONS TABLES DEFMARK = % ORMARK = | BLOCKB = /. BLOCKE = ./ COMMB = -- COMME = LOADF = 70 1Grammar Constants Number of Terminals 94 Number of Non Terminals 218 Number of Rules 471 Number of Items 1623 Number of states 942 Number of shift entries 1550 Number of goto entries 2137 Number of reduce entries 158 Number of entries saved by default reductions 5825 Number of shift/reduce conflicts 0 Number of reduce/reduce conflicts 0 1The following symbols are not used in any right hand side comment_literal 1 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 1 Rules 1 pragma ::= PRAGMA identifier ( general_component_associations ) ; 2 pragma ::= PRAGMA identifier ; 3 basic_declaration ::= object_declaration 4 basic_declaration ::= number_declaration 5 basic_declaration ::= type_declaration 6 basic_declaration ::= subtype_declaration 7 basic_declaration ::= subprogram_declaration 8 basic_declaration ::= package_declaration 9 basic_declaration ::= task_declaration 10 basic_declaration ::= generic_declaration 11 basic_declaration ::= exception_declaration 12 basic_declaration ::= generic_instantiation 13 basic_declaration ::= renaming_declaration 14 object_declaration ::= identifier_list : subtype_indication [:=expression] ; 15 object_declaration ::= identifier_list : CONSTANT subtype_indication [:=expression] ; 16 object_declaration ::= identifier_list : constrained_array_definition [:=expression] ; 17 object_declaration ::= identifier_list : CONSTANT constrained_array_definition [:=expression] ; 18 number_declaration ::= identifier_list : CONSTANT := expression ; 19 identifier_list ::= identifier {,identifier} 20 type_declaration ::= full_type_declaration 21 type_declaration ::= incomplete_type_declaration 22 type_declaration ::= private_type_declaration 23 full_type_declaration ::= TYPE identifier IS type_definition ; 24 full_type_declaration ::= TYPE identifier ( discriminant_specification {;discriminant_specification} ) IS type_definition ; 25 type_definition ::= enumeration_type_definition 26 type_definition ::= integer_type_definition 27 type_definition ::= real_type_definition 28 type_definition ::= array_type_definition 29 type_definition ::= record_type_definition 30 type_definition ::= access_type_definition 31 type_definition ::= derived_type_definition 32 subtype_declaration ::= SUBTYPE identifier IS subtype_indication ; 33 subtype_indication ::= type_mark 34 subtype_indication ::= type_mark constraint 35 type_mark ::= type_name|subtype_name 36 constraint ::= range_constraint 37 constraint ::= floating_point_constraint 38 constraint ::= fixed_point_constraint 39 constraint ::= ( general_component_associations ) 40 derived_type_definition ::= NEW subtype_indication 41 range_constraint ::= RANGE simple_expression 42 range_constraint ::= RANGE simple_expression .. simple_expression 43 enumeration_type_definition ::= ( enumeration_literal_specification {,enumeration_literal_specification} ) 44 enumeration_literal_specification ::= enumeration_literal 45 enumeration_literal ::= identifier 46 enumeration_literal ::= character_literal 47 integer_type_definition ::= range_constraint 48 real_type_definition ::= floating_point_constraint 49 real_type_definition ::= fixed_point_constraint 50 floating_point_constraint ::= floating_accuracy_definition [range_constraint] 51 floating_accuracy_definition ::= DIGITS simple_expression 52 fixed_point_constraint ::= fixed_accuracy_definition [range_constraint] 53 fixed_accuracy_definition ::= DELTA simple_expression 54 array_type_definition ::= unconstrained_array_definition 55 array_type_definition ::= constrained_array_definition 56 unconstrained_array_definition ::= ARRAY ( index_subtype_definition {,index_subtype_definition} ) OF subtype_indication 57 constrained_array_definition ::= ARRAY index_constraint OF subtype_indication 58 index_subtype_definition ::= name RANGE <> 59 index_constraint ::= ( discrete_range {,discrete_range} ) 60 discrete_range ::= name range_constraint 61 discrete_range ::= range 62 range ::= simple_expression 63 range ::= simple_expression .. simple_expression 64 record_type_definition ::= RECORD component_list END RECORD 65 component_list ::= {pragma_decl} {component_declaration} component_declaration {pragma_decl} 66 component_list ::= {pragma_decl} {component_declaration} variant_part {pragma_decl} 67 component_list ::= NULL ; {pragma_decl} 68 component_declaration ::= identifier_list : subtype_indication [:=expression] ; 69 discriminant_specification ::= identifier_list : type_mark [:=expression] 70 variant_part ::= CASE identifier IS {pragma_variant} variant {variant} END CASE ; 71 variant ::= WHEN choice {|choice} => component_list 72 variant ::= WHEN OTHERS => component_list 73 choice ::= simple_expression 74 choice ::= simple_expression .. simple_expression 75 choice ::= name range_constraint 76 access_type_definition ::= ACCESS subtype_indication 77 incomplete_type_declaration ::= TYPE identifier ; 78 incomplete_type_declaration ::= TYPE identifier ( discriminant_specification {;discriminant_specification} ) ; 79 declarative_part ::= {basic_declarative_item} 80 declarative_part ::= {basic_declarative_item} body {later_declarative_item} 81 basic_declarative_item ::= basic_declaration 82 basic_declarative_item ::= representation_clause 83 basic_declarative_item ::= use_clause 84 later_declarative_item ::= body 85 later_declarative_item ::= subprogram_declaration 86 later_declarative_item ::= package_declaration 87 later_declarative_item ::= task_declaration 88 later_declarative_item ::= generic_declaration 89 later_declarative_item ::= use_clause 90 later_declarative_item ::= generic_instantiation 91 body ::= proper_body 92 body ::= body_stub 93 proper_body ::= subprogram_body 94 proper_body ::= package_body 95 proper_body ::= task_body 96 name ::= identifier 97 name ::= character_literal 98 name ::= string_literal 99 name ::= indexed_component 100 name ::= selected_component 101 name ::= attribute 102 indexed_component ::= name ( general_component_associations ) 103 selected_component ::= name . selector 104 selected_component ::= name . ALL 105 selector ::= identifier 106 selector ::= character_literal 107 selector ::= string_literal 108 attribute ::= name ' attribute_designator 109 attribute_designator ::= identifier 110 attribute_designator ::= DIGITS 111 attribute_designator ::= DELTA 112 attribute_designator ::= RANGE 113 aggregate ::= ( component_associations ) 114 component_associations ::= expression,expression{,expression} [,others=>expression] 115 component_associations ::= expression,expression{,expression} , choice{|choice}=>expression {,choice{|choice}=>expression} [,others=>expression] 116 component_associations ::= expression , choice{|choice}=>expression {,choice{|choice}=>expression} [,others=>expression] 117 component_associations ::= choice{|choice}=>expression {,choice{|choice}=>expression} [,others=>expression] 118 component_associations ::= expression , others=>expression 119 component_associations ::= others=>expression 120 general_component_associations ::= ga_expression{,ga_expression} 121 general_component_associations ::= ga_expression{,ga_expression} , identifier{|identifier}=>expression {,identifier{|identifier}=>expression} 122 general_component_associations ::= identifier{|identifier}=>expression {,identifier{|identifier}=>expression} 123 expression ::= relation 124 expression ::= relation{AND__relation} 125 expression ::= relation{OR__relation} 126 expression ::= relation{XOR__relation} 127 expression ::= relation{AND__THEN__relation} 128 expression ::= relation{OR__ELSE__relation} 129 relation ::= simple_expression [relational_operator__simple_expression] 130 relation ::= simple_expression [NOT]IN range 131 simple_expression ::= [unary_adding_operator]term{binary_adding_operator__term} 132 term ::= factor{multiplying_operator__factor} 133 factor ::= primary [exponentiating_operator__primary] 134 factor ::= high_precedence_unary_operator primary 135 parenthesized_expression ::= ( expression ) 136 primary ::= numeric_literal 137 primary ::= NULL 138 primary ::= name 139 primary ::= allocator 140 primary ::= qualified_expression 141 primary ::= aggregate 142 primary ::= parenthesized_expression 143 relational_operator ::= = 144 relational_operator ::= /= 145 relational_operator ::= < 146 relational_operator ::= <= 147 relational_operator ::= > 148 relational_operator ::= >= 149 binary_adding_operator ::= + 150 binary_adding_operator ::= - 151 binary_adding_operator ::= & 152 unary_adding_operator ::= + 153 unary_adding_operator ::= - 154 high_precedence_unary_operator ::= ABS 155 high_precedence_unary_operator ::= NOT 156 multiplying_operator ::= * 157 multiplying_operator ::= / 158 multiplying_operator ::= MOD 159 multiplying_operator ::= REM 160 exponentiating_operator ::= ** 161 qualified_expression ::= name ' aggregate 162 qualified_expression ::= name ' parenthesized_expression 163 allocator ::= NEW type_mark 164 allocator ::= NEW type_mark ( general_component_associations ) 165 allocator ::= NEW expanded_name ' parenthesized_expression 166 allocator ::= NEW expanded_name ' aggregate 167 sequence_of_statements ::= {pragma_stm} statement {statement} 168 statement ::= simple_statement 169 statement ::= compound_statement 170 statement ::= {label}+ simple_statement 171 statement ::= {label}+ compound_statement 172 simple_statement ::= null_statement 173 simple_statement ::= assignment_statement 174 simple_statement ::= exit_statement 175 simple_statement ::= return_statement 176 simple_statement ::= goto_statement 177 simple_statement ::= delay_statement 178 simple_statement ::= abort_statement 179 simple_statement ::= raise_statement 180 simple_statement ::= code_statement 181 simple_statement ::= call_statement 182 compound_statement ::= if_statement 183 compound_statement ::= case_statement 184 compound_statement ::= loop_statement 185 compound_statement ::= block_statement 186 compound_statement ::= accept_statement 187 compound_statement ::= select_statement 188 label ::= << identifier >> 189 null_statement ::= NULL ; 190 assignment_statement ::= name := expression ; 191 if_statement ::= IF condition_THEN__sequence_of_statements {ELSIF__condition__THEN__sequence_of_statements} [ELSE__sequence_of_statements] END IF ; 192 condition ::= expression 193 case_statement ::= CASE expression IS {pragma_alt} case_statement_alternative {case_statement_alternative} END CASE ; 194 case_statement_alternative ::= WHEN choice {|choice} => sequence_of_statements 195 case_statement_alternative ::= WHEN OTHERS => sequence_of_statements 196 loop_statement ::= [loop_identifier:] LOOP sequence_of_statements END LOOP [identifier] ; 197 loop_statement ::= [loop_identifier:] iteration_rule LOOP sequence_of_statements END LOOP [identifier] ; 198 iteration_rule ::= WHILE condition 199 iteration_rule ::= FOR identifier IN discrete_range 200 iteration_rule ::= FOR identifier IN REVERSE discrete_range 201 declarative_part__begin_end_block ::= declarative_part begin_end_block 202 begin_end_block ::= BEGIN sequence_of_statements END 203 begin_end_block ::= BEGIN sequence_of_statements EXCEPTION {pragma_alt}__exception_handler_list END 204 block_statement ::= [block_identifier:] DECLARE declarative_part__begin_end_block [identifier] ; 205 block_statement ::= [block_identifier:] begin_end_block [identifier] ; 206 exit_statement ::= EXIT ; 207 exit_statement ::= EXIT WHEN condition ; 208 exit_statement ::= EXIT expanded_name ; 209 exit_statement ::= EXIT expanded_name WHEN condition ; 210 return_statement ::= RETURN ; 211 return_statement ::= RETURN expression ; 212 goto_statement ::= GOTO expanded_name ; 213 subprogram_declaration ::= subprogram_specification ; 214 subprogram_specification ::= PROCEDURE identifier 215 subprogram_specification ::= PROCEDURE identifier ( parameter_specification {;parameter_specification} ) 216 subprogram_specification ::= FUNCTION designator RETURN type_mark 217 subprogram_specification ::= FUNCTION designator ( parameter_specification {;parameter_specification} ) RETURN type_mark 218 designator ::= identifier 219 designator ::= string_literal 220 parameter_specification ::= identifier_list mode type_mark [:=expression] 221 mode ::= generic_parameter_mode 222 mode ::= : OUT 223 generic_parameter_mode ::= : 224 generic_parameter_mode ::= : IN 225 generic_parameter_mode ::= : IN OUT 226 subprogram_body ::= subprogram_specification IS declarative_part__begin_end_block [end_designator] ; 227 call_statement ::= name ; 228 package_declaration ::= package_specification ; 229 package_specification ::= package_spec_indicator {basic_declarative_item} END [identifier] 230 package_specification ::= package_spec_indicator {basic_declarative_item} PRIVATE {basic_declarative_item} END [identifier] 231 package_spec_indicator ::= PACKAGE identifier IS 232 package_body ::= package_body_indicator declarative_part END [identifier] ; 233 package_body ::= package_body_indicator declarative_part__begin_end_block [identifier] ; 234 package_body_indicator ::= PACKAGE BODY identifier IS 235 private_type_declaration ::= TYPE identifier IS LIMITED PRIVATE ; 236 private_type_declaration ::= TYPE identifier ( discriminant_specification {;discriminant_specification} ) IS LIMITED PRIVATE ; 237 private_type_declaration ::= TYPE identifier IS PRIVATE ; 238 private_type_declaration ::= TYPE identifier ( discriminant_specification {;discriminant_specification} ) IS PRIVATE ; 239 use_clause ::= USE expanded_name {,expanded_name} ; 240 renaming_declaration ::= identifier_list : type_mark RENAMES name ; 241 renaming_declaration ::= identifier_list : EXCEPTION RENAMES expanded_name ; 242 renaming_declaration ::= PACKAGE identifier RENAMES expanded_name ; 243 renaming_declaration ::= subprogram_specification RENAMES name ; 244 task_declaration ::= task_specification ; 245 task_specification ::= TASK identifier 246 task_specification ::= TASK TYPE identifier 247 task_specification ::= TASK identifier IS {entry_declaration} {representation_clause} END [identifier] 248 task_specification ::= TASK TYPE identifier IS {entry_declaration} {representation_clause} END [identifier] 249 task_body ::= task_body_indicator declarative_part__begin_end_block [identifier] ; 250 task_body_indicator ::= TASK BODY identifier IS 251 entry_declaration ::= ENTRY identifier [(discrete_range)][formal_part] ; 252 accept_statement ::= ACCEPT identifier [(expression)][formal_part] ; 253 accept_statement ::= ACCEPT identifier [(expression)][formal_part] DO sequence_of_statements END [identifier] ; 254 delay_statement ::= DELAY simple_expression ; 255 select_statement ::= selective_wait 256 select_statement ::= conditional_entry_call 257 select_statement ::= timed_entry_call 258 selective_wait ::= SELECT select_alternative {OR__select_alternative} [ELSE__sequence_of_statements] END SELECT ; 259 select_alternative ::= {pragma_stm} WHEN condition => selective_wait_alternative 260 select_alternative ::= {pragma_stm} selective_wait_alternative 261 selective_wait_alternative ::= accept_alternative 262 selective_wait_alternative ::= delay_alternative 263 selective_wait_alternative ::= terminate_alternative 264 accept_alternative ::= accept_statement [sequence_of_statements] 265 delay_alternative ::= delay_statement [sequence_of_statements] 266 terminate_alternative ::= TERMINATE ; {pragma_stm} 267 conditional_entry_call ::= SELECT {pragma_stm} call_statement [sequence_of_statements] ELSE sequence_of_statements END SELECT ; 268 timed_entry_call ::= SELECT {pragma_stm} call_statement [sequence_of_statements] OR {pragma_stm} delay_alternative END SELECT ; 269 abort_statement ::= ABORT name {,name} ; 270 compilation ::= {compilation_unit} 271 pragma_header ::= PRAGMA identifier 272 compilation_unit ::= pragma_header ( general_component_associations ) ; 273 compilation_unit ::= pragma_header ; 274 compilation_unit ::= context_clause library_or_secondary_unit 275 library_or_secondary_unit ::= subprogram_declaration 276 library_or_secondary_unit ::= package_declaration 277 library_or_secondary_unit ::= generic_declaration 278 library_or_secondary_unit ::= generic_instantiation 279 library_or_secondary_unit ::= subprogram_body 280 library_or_secondary_unit ::= package_body 281 library_or_secondary_unit ::= subunit 282 context_clause ::= {with_clause{use_clause}} 283 with_clause ::= WITH identifier {,used_identifier} ; 284 body_stub ::= subprogram_specification IS SEPARATE ; 285 body_stub ::= PACKAGE BODY identifier IS SEPARATE ; 286 body_stub ::= TASK BODY identifier IS SEPARATE ; 287 subunit ::= SEPARATE ( expanded_name ) proper_body 288 exception_declaration ::= identifier_list : EXCEPTION ; 289 exception_handler ::= WHEN exception_choice {|exception_choice} => sequence_of_statements 290 exception_choice ::= expanded_name 291 exception_choice ::= OTHERS 292 raise_statement ::= RAISE ; 293 raise_statement ::= RAISE expanded_name ; 294 generic_declaration ::= generic_specification ; 295 generic_specification ::= generic_formal_part subprogram_specification 296 generic_specification ::= generic_formal_part package_specification 297 generic_formal_part ::= GENERIC {generic_parameter_declaration} 298 generic_parameter_declaration ::= identifier_list generic_parameter_mode type_mark [:=expression] ; 299 generic_parameter_declaration ::= TYPE identifier IS generic_type_definition ; 300 generic_parameter_declaration ::= TYPE identifier ( discriminant_specification {;discriminant_specification} ) IS generic_type_definition ; 301 generic_parameter_declaration ::= WITH subprogram_specification [IS__name__or__<>] ; 302 generic_type_definition ::= ( <> ) 303 generic_type_definition ::= RANGE <> 304 generic_type_definition ::= DIGITS <> 305 generic_type_definition ::= DELTA <> 306 generic_type_definition ::= LIMITED PRIVATE 307 generic_type_definition ::= PRIVATE 308 generic_type_definition ::= array_type_definition 309 generic_type_definition ::= access_type_definition 310 generic_instantiation ::= PACKAGE identifier IS NEW expanded_name ; 311 generic_instantiation ::= PACKAGE identifier IS NEW expanded_name ( generic_association {,generic_association} ) ; 312 generic_instantiation ::= FUNCTION designator IS NEW expanded_name ; 313 generic_instantiation ::= FUNCTION designator IS NEW expanded_name ( generic_association {,generic_association} ) ; 314 generic_instantiation ::= subprogram_specification IS NEW expanded_name ; 315 generic_instantiation ::= subprogram_specification IS NEW expanded_name ( generic_association {,generic_association} ) ; 316 generic_association ::= [generic_formal_parameter=>]generic_actual_parameter 317 generic_formal_parameter ::= identifier 318 generic_formal_parameter ::= string_literal 319 generic_actual_parameter ::= expression 320 representation_clause ::= length_clause 321 representation_clause ::= enumeration_representation_clause 322 representation_clause ::= address_clause 323 representation_clause ::= record_representation_clause 324 length_clause ::= FOR attribute USE simple_expression ; 325 enumeration_representation_clause ::= FOR identifier USE aggregate ; 326 record_representation_clause ::= FOR identifier USE RECORD {component_clause} END RECORD ; 327 record_representation_clause ::= FOR identifier USE RECORD alignment_clause {component_clause} END RECORD ; 328 component_clause ::= name AT simple_expression range_constraint ; 329 alignment_clause ::= AT MOD simple_expression ; 330 address_clause ::= FOR identifier USE AT simple_expression ; 331 code_statement ::= name ' aggregate ; 332 {pragma_decl} ::= EMPTY 333 {pragma_decl} ::= {pragma_decl} pragma 334 {pragma_variant} ::= EMPTY 335 {pragma_variant} ::= {pragma_variant} pragma 336 {pragma_stm} ::= EMPTY 337 {pragma_stm} ::= {pragma_stm} pragma 338 {pragma_alt} ::= EMPTY 339 {pragma_alt} ::= {pragma_alt} pragma 340 [:=expression] ::= EMPTY 341 [:=expression] ::= := expression 342 {,identifier} ::= EMPTY 343 {,identifier} ::= {,identifier} , identifier 344 type_name|subtype_name ::= expanded_name 345 expanded_name ::= identifier 346 expanded_name ::= expanded_name . identifier 347 {,enumeration_literal_specification} ::= EMPTY 348 {,enumeration_literal_specification} ::= {,enumeration_literal_specification} , enumeration_literal_specification 349 [range_constraint] ::= EMPTY 350 [range_constraint] ::= range_constraint 351 {,index_subtype_definition} ::= EMPTY 352 {,index_subtype_definition} ::= {,index_subtype_definition} , index_subtype_definition 353 {,discrete_range} ::= EMPTY 354 {,discrete_range} ::= {,discrete_range} , discrete_range 355 {component_declaration} ::= EMPTY 356 {component_declaration} ::= {component_declaration} component_declaration {pragma_decl} 357 {;discriminant_specification} ::= EMPTY 358 {;discriminant_specification} ::= {;discriminant_specification} ; discriminant_specification 359 {variant} ::= EMPTY 360 {variant} ::= {variant} variant 361 {|choice} ::= EMPTY 362 {|choice} ::= {|choice} '|' choice 363 {basic_declarative_item} ::= {pragma_decl} 364 {basic_declarative_item} ::= {basic_declarative_item} basic_declarative_item {pragma_decl} 365 {later_declarative_item} ::= {pragma_decl} 366 {later_declarative_item} ::= {later_declarative_item} later_declarative_item {pragma_decl} 367 expression,expression{,expression} ::= expression , expression 368 expression,expression{,expression} ::= expression,expression{,expression} , expression 369 choice{|choice}=>expression ::= choice {|choice} => expression 370 {,choice{|choice}=>expression} ::= EMPTY 371 {,choice{|choice}=>expression} ::= {,choice{|choice}=>expression} , choice{|choice}=>expression 372 [,others=>expression] ::= EMPTY 373 [,others=>expression] ::= , others=>expression 374 others=>expression ::= OTHERS => expression 375 ga_expression ::= expression 376 ga_expression ::= simple_expression .. simple_expression 377 ga_expression ::= name range_constraint 378 ga_expression{,ga_expression} ::= ga_expression 379 ga_expression{,ga_expression} ::= ga_expression{,ga_expression} , ga_expression 380 identifier{|identifier}=>expression ::= identifier {|identifier} => expression 381 {,identifier{|identifier}=>expression} ::= EMPTY 382 {,identifier{|identifier}=>expression} ::= {,identifier{|identifier}=>expression} , identifier{|identifier}=>expression 383 {|identifier} ::= EMPTY 384 {|identifier} ::= {|identifier} '|' identifier 385 relation{AND__relation} ::= relation AND relation 386 relation{AND__relation} ::= relation{AND__relation} AND relation 387 relation{OR__relation} ::= relation OR relation 388 relation{OR__relation} ::= relation{OR__relation} OR relation 389 relation{XOR__relation} ::= relation XOR relation 390 relation{XOR__relation} ::= relation{XOR__relation} XOR relation 391 relation{AND__THEN__relation} ::= relation AND THEN relation 392 relation{AND__THEN__relation} ::= relation{AND__THEN__relation} AND THEN relation 393 relation{OR__ELSE__relation} ::= relation OR ELSE relation 394 relation{OR__ELSE__relation} ::= relation{OR__ELSE__relation} OR ELSE relation 395 [relational_operator__simple_expression] ::= EMPTY 396 [relational_operator__simple_expression] ::= relational_operator simple_expression 397 [NOT]IN ::= IN 398 [NOT]IN ::= NOT IN 399 [unary_adding_operator]term{binary_adding_operator__term} ::= term 400 [unary_adding_operator]term{binary_adding_operator__term} ::= unary_adding_operator term 401 [unary_adding_operator]term{binary_adding_operator__term} ::= [unary_adding_operator]term{binary_adding_operator__term} binary_adding_operator term 402 factor{multiplying_operator__factor} ::= factor 403 factor{multiplying_operator__factor} ::= factor{multiplying_operator__factor} multiplying_operator factor 404 [exponentiating_operator__primary] ::= EMPTY 405 [exponentiating_operator__primary] ::= exponentiating_operator primary 406 {statement} ::= {pragma_stm} 407 {statement} ::= {statement} statement {pragma_stm} 408 {label}+ ::= label 409 {label}+ ::= {label}+ label 410 condition_THEN__sequence_of_statements ::= condition THEN sequence_of_statements 411 {ELSIF__condition__THEN__sequence_of_statements} ::= EMPTY 412 {ELSIF__condition__THEN__sequence_of_statements} ::= {ELSIF__condition__THEN__sequence_of_statements} ELSIF condition THEN sequence_of_statements 413 [ELSE__sequence_of_statements] ::= EMPTY 414 [ELSE__sequence_of_statements] ::= ELSE sequence_of_statements 415 {case_statement_alternative} ::= EMPTY 416 {case_statement_alternative} ::= {case_statement_alternative} case_statement_alternative 417 [loop_identifier:] ::= EMPTY 418 [loop_identifier:] ::= identifier : 419 [identifier] ::= EMPTY 420 [identifier] ::= identifier 421 [block_identifier:] ::= EMPTY 422 [block_identifier:] ::= identifier : 423 {pragma_alt}__exception_handler_list ::= {pragma_alt} exception_handler_list 424 exception_handler_list ::= exception_handler 425 exception_handler_list ::= exception_handler_list exception_handler 426 {;parameter_specification} ::= EMPTY 427 {;parameter_specification} ::= {;parameter_specification} ; parameter_specification 428 [end_designator] ::= EMPTY 429 [end_designator] ::= identifier 430 [end_designator] ::= string_literal 431 {,expanded_name} ::= EMPTY 432 {,expanded_name} ::= {,expanded_name} , expanded_name 433 {entry_declaration} ::= {pragma_decl} 434 {entry_declaration} ::= {entry_declaration} entry_declaration {pragma_decl} 435 {representation_clause} ::= EMPTY 436 {representation_clause} ::= {representation_clause} representation_clause {pragma_decl} 437 [(discrete_range)][formal_part] ::= EMPTY 438 [(discrete_range)][formal_part] ::= ( parameter_specification {;parameter_specification} ) 439 [(discrete_range)][formal_part] ::= ( discrete_range ) 440 [(discrete_range)][formal_part] ::= ( discrete_range ) ( parameter_specification {;parameter_specification} ) 441 [(expression)][formal_part] ::= EMPTY 442 [(expression)][formal_part] ::= ( parameter_specification {;parameter_specification} ) 443 [(expression)][formal_part] ::= ( expression ) 444 [(expression)][formal_part] ::= ( expression ) ( parameter_specification {;parameter_specification} ) 445 {OR__select_alternative} ::= EMPTY 446 {OR__select_alternative} ::= {OR__select_alternative} OR select_alternative 447 [sequence_of_statements] ::= {pragma_stm} 448 [sequence_of_statements] ::= sequence_of_statements 449 {,name} ::= EMPTY 450 {,name} ::= {,name} , name 451 {compilation_unit} ::= compilation_unit 452 {compilation_unit} ::= {compilation_unit} compilation_unit 453 {with_clause{use_clause}} ::= EMPTY 454 {with_clause{use_clause}} ::= {with_clause{use_clause}} with_clause use_clause_list 455 use_clause_list ::= {pragma_decl} 456 use_clause_list ::= use_clause_list use_clause {pragma_decl} 457 {,used_identifier} ::= EMPTY 458 {,used_identifier} ::= {,used_identifier} , identifier 459 {|exception_choice} ::= EMPTY 460 {|exception_choice} ::= {|exception_choice} '|' exception_choice 461 {generic_parameter_declaration} ::= EMPTY 462 {generic_parameter_declaration} ::= {generic_parameter_declaration} generic_parameter_declaration 463 [IS__name__or__<>] ::= EMPTY 464 [IS__name__or__<>] ::= IS name 465 [IS__name__or__<>] ::= IS <> 466 {,generic_association} ::= EMPTY 467 {,generic_association} ::= {,generic_association} , generic_association 468 [generic_formal_parameter=>]generic_actual_parameter ::= generic_actual_parameter 469 [generic_formal_parameter=>]generic_actual_parameter ::= generic_formal_parameter => generic_actual_parameter 470 {component_clause} ::= {pragma_decl} 471 {component_clause} ::= {component_clause} component_clause {pragma_decl} 1Non terminalss $ACC compilation 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 parameter_specification {;parameter_specification} designator mode generic_parameter_mode [end_designator] package_specification package_spec_indicator package_body_indicator {,expanded_name} task_specification {entry_declaration} {representation_clause} task_body_indicator [(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}} {,used_identifier} with_clause exception_choice {|exception_choice} exception_handler generic_specification generic_formal_part {generic_parameter_declaration} generic_parameter_declaration generic_type_definition [IS__name__or__<>] 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 1Information about Action Tables Number of Entries 3845 Origin Table Size 5501 Action Table Size 8286 Number Unused 2751 Distribution of entries 1905 646 157 34 7 1 0 0 1Timing Statistics Cpu Time Elapsed LG Reads LG Writes Parse: 9043 9043 0 35 Preliminary: 311 311 0 68 First Map: 2014 2014 0 6 Item Creation: 1303 1303 0 10 Follow Map: 1056 1056 0 0 Closure: 999 999 0 0 States: 10331 10331 0 305 Reductions: 10801 10801 0 86 Summary: 1273 1272 0 0 Compress: 2747 2747 0 77 Table Dump: 2000 2001 0 0 --:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: --stmtprof.cnt --:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: [NOSC.RELEASES.V0101.STMTPROF.SOURCE]GRMCONST.BDY 32 31 [NOSC.RELEASES.V0101.STMTPROF.SOURCE]PTBLS.BDY 31801 3539 [NOSC.RELEASES.V0101.STMTPROF.SOURCE]SPUTILS.SPC 56 188 [NOSC.RELEASES.V0101.STMTPROF.SOURCE]SPUTILS.BDY 500 448 [NOSC.RELEASES.V0101.STMTPROF.SOURCE]STMTPROF.ADA 311 227 [NOSC.RELEASES.V0101.STMTPROF.SOURCE]APPLYACT.SUB 163 573 [NOSC.RELEASES.V0101.STMTPROF.SOURCE]GETNEXT.SUB 38 61