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 / stnd.doc < prev next >

Wrap

Text File | 1988-05-03 | 73.2 KB | 2,565 lines

--:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: --read.me --:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: To build the standards checker tool: 1. Compile all the abstractions into a program library (see READ.ME in abstractions directory for details). 2. Compile everything named in the STANDARDS.CO file into the program library containing the abstractions or a sublibrary whose parent library contains all the abstractions. STANDARDS.CO lists file names in the correct compilation order. 3. Link stndcheck with the program library where everything was compiled. To do this using the DEC Ada compiler type: $ acs link stndcheck To run the tool on VMS: 1. Define a logical symbol for the executable of stndcheck For example, check :== $$DRB1:[NOSC.TOOLS.STANDARDS]STNDCHECK.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. check ( Source=>"filename" [, Output=>"output_file"] [,Print=>print_type] [, Report=>report_type] ); Entering the command compile_order with no parameters gives a brief description of how to use the tool. For example, check ( Source=> "testfile.ada", Print=>SOURCE); -- In this example the input file to be checked is testfile.ada and -- the output will go to the default output. The report will be -- the source combined with the violation warnings, and all violations check ( Source=> "foo.ada", Output=>"report.out", Report=>FIRST); -- This example shows a source file of foo.ada with the report being -- put in the file report.out. The report will show only the violations -- without the source code and only the first of each type of -- violation will be reported Files contained in this directory: STANDARDS.CO -- Compilation order for standards checker sources STANDARDS.EXE -- VMS 4.0 standards checker executable The [.SOURCE] subdirectory contains most of the sources that make up the standards checker tool. Other sources are contained in the abstractions directory. Files in [.SOURCE]: The source files that make up the standards checker tool are as follows: STNDCHECK.ADA -- the driver which deals with the command line, and -- main procedure SCUTILS.SPC -- the procedures which control the actions done by the parser SCUTILS.BDY SCDECLS.DAT -- the package which contains all the structures to -- customize the checker The tool runs using the parser. Most of the sources needed for the parser are in the parser abstraction. The five units that are unique to this tool are below: 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. WRITELINE.SUB -- Writes a line of source code out as it's read in when -- print=>source The [.TEST] subdirectory contains the tests used in testing standards checker Files in [.TEST]: Test this tool using the acvc a tests. The only construct not tested by the acvcs is a code statement and for that there is the file code.tst. The [.DOC] subdirectory contains the documentation for standards checker. Files in [.DOC]: USERMAN.MEM -- Standards checker user's manual USERMAN.RNO -- Runoff input for user's manual RELEASE.NTS -- Release notes STDCKGRM.LIS -- Listing of standards checker grammar. The rule numbers in this file may be used to make changes to the case statement in the Apply_Actions subunit. STANDARDS.CNT-- Statement counts and line counts of standards checker source files. --:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: --userman.mem --:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: STANDARDS CHECKER _________ _______ _________ _______ 1 STANDARDS CHECKER ___________ 1.1 Description This tool checks Ada program library units for adherence to Ada programming standards. The standards to be checked are specified in a predefined standards package. Note that there may be cases in which the use of non-standard constructs, names, etc. is justified; for example, it may be clearer to use a non-standard construct in some cases or it may sometimes actually be necessary. The messages produced by Check_Standards are only intended to point out portions of code which do not conform to standards. One may then decide whether the non-standard construct, organization, etc. is justified for the particular situation. _______ ______ 1.2 Command Format type PRINT_TYPE is (VIOLATION, SOURCE); type REPORT_TYPE is (EVERY, FIRST); CHECK_STANDARDS ( --| Check standards of input file SOURCE : in STRING; --| Name of the source input file OUTPUT : in STRING := ""; --| Name of an output file PRINT : in PRINT_TYPE := --| Type of output: with source VIOLATION; --| and violations or just --| violations REPORT : in REPORT_TYPE:= --| Type of report: all errors EVERY --| reported or just the first of --| each type of violation ); SOURCE The name of the source file to be checked. It must be syntactically correct or the tool will stop and report the syntax error. OUTPUT The name of a file in which to put the output. If the name is left blank the output will go to the standard output. An invalid file name will result in an error being reported. PRINT The type of output to put in the report. If this is VIOLATION only the violations will be reported with line numbers being indicated in the messages. If the print type is SOURCE then the output will include the text from the source file with the violations being reported in the source as they occur. REPORT This indicates how the violations are to be reported. It can either report every violation, or just the first one of each kind. Page 2 ____ ___ _________ ___ _______ 1.3 When The Standards Are Checked Due to the character of the checks being performed it is not sensible to do all of the checks in all contexts. Checks for particular constructs can obviously only be checked for in the contexts on which they are legal. For example, a goto statement may only appear in a body. The following descriptions indicate when the checks will take place if it is not already obvious. _________ ___ _________ 2 RATIONALE FOR STANDARDS _________ ___ _______ ____________ 2.1 Standards For Overall Organization ___________ 2.1.1 Max_Nesting - Checks that procedures and functions are not nested. Since packages may be nested, subprogram nesting may be avoided. In this way, nesting to avoid parameter passing will be discouraged. __________________ 2.1.2 Max_Ada_Statements - Checks that no single subprogram exceeds 100 statements. Long subprograms may indicate a lack of abstraction or misuse of control structures, especially in the case of exception handling, unnecessary repetition of code or mixing of functionality. Limiting the size of subprograms can help to reduce these problems. Statements are counted in the same way that the Statement_Profile tool counts them. ______________________ 2.1.3 Private_Types_Checking - Checks that non-scalar types defined in the visible part of a package are private or limited private types. Declaring the types as private introduces the concept of data abstraction by hiding the implementation of the type and providing a cleaner interface to it. The operations on a type will then be clearly defined, the type will be easier to use and the proper use of the type will be enforced. _________ ___ __________ __________ 2.2 Standards For Particular Constructs _____________ 2.2.1 Goto_Checking - Checks for explicit Gotos in the library. The harmful effects of Gotos are well known and need not be described here. Page 3 __________________ 2.2.2 Exit_When_Checking - _________ Checks that "exit when condition" is used rather than "if _________ condition exit" for exits from a loop. Again, enforces the use of the appropriate construct. _____________________ 2.2.3 Boolean_Test_Checking - _______ _____ Checks that no expressions of the form "if boolean value = true" appear. Not only is this type of statement redundant and potentially confusing, but it may also cause unintended results because of precedence rules for equality. _________ ___ _________ _______ 2.3 Standards For Parameter Passing ________ 2.3.1 Max_Args - Checks that the number of arguments to a subprogram does not exceed four. If several parameters are logically linked, it is sometimes possible to encapsulate them into a single data abstraction, passed as a single argument. This standard is checked in the visible part of any packages and for any subprogram body and specification. It is also necessary to check subprogram bodies because there may only be a body with an implicit spec, so the body will be the only place the tool is able to check it. Page 4 _________ __ _______ ___________ 2.4 Standards To Enforce Portability ______________________ 2.4.1 Builtin_Types_Checking - Checks for occurrences of "integer" and other builtin types and subtypes. If builtin types are used explicitly, rather than defining a subtype as a subrange of the type, the code is no longer portable. In addition, run time bounds checking is provided. If a value is out of bounds, an exception will be raised. The use of subtypes may also reduce the amount of storage space necessary. This check is performed on all parts of a program. __________________ 2.4.2 Acceptable_Pragmas - Checks that no pragmas other than the following are used anywhere in the program: elaborate, page, inline Certain pragmas are not portable, and should thus be avoided if possible. __________________ 2.4.3 Rep_Specs_Checking - Checks for the use of Rep Specs, which are not portable constructs. _______________________ 2.4.4 Code_Statement_Checking - Checks for the use of code statements, which are not portable constructs. _________ __ _______ _______________ 2.5 Standards To Enforce Maintainability ______________________ 2.5.1 Named_Subtype_Checking - Checks that named subtypes are defined instead of using explicit range constraints in parameter or discriminant specifications. If named subtypes are defined, changes to the range values need only be made in one place. The descriptive names also provide additional documentation. This is checked everywhere but in subtype definitions. ______________________ 2.5.2 Named_Literal_Checking - Page 5 Checks that named literals are defined. Unnamed literals like "27" should only appear in "named number" declarations. A comment should justify the particular value, indicating other possible values if later adjustment is possible. Again, if the value is to be changed later, it is only necessary to change it in one place. The names also provide additional documentation. It does however, seem reasonable that certain numbers like "1" can be exempt. The numbers presently exempt are "0,1,2", but these can be changed. This check is done in all bodies. ______ _________ 2.6 Naming Standards _________ 2.6.1 Type_Name - Defines conventions for naming types and checks visible parts to make sure these conventions are adhered to for type definitions. Currently, no standard prefixes are defined; the standard suffixes are as follows: Number Name Range Task Record Specifier Descriptor Handle Array String Node Ptr Type Defining prefixes and suffixes for types helps to distinguish between types and objects, as well as providing documentation in the names and standardizing style. Note that certain suffixes are logical for different types, and that it wouldn't make sense to name something xRecord if it wasn't a record. The tool does check that the proper suffixes are used with the type of definition it is. For a fuller description of the suffixes see the appendix. This check is performed on all type declarations. ____________ 2.6.2 Package_Name - Defines conventions for naming packages and checks packages to make sure these conventions are adhered to. Currently, no standard package names are defined. Standard names for packages make it easier to determine the function of a particular package from its name. This check is only done on package specs as we don't want to report things twice if we don't have to. ______________ 2.6.3 Procedure_Name - Defines conventions for naming procedures and checks procedures to make sure these conventions are adhered to. Currently the prefixes defined are as follows: Allocate Free Get Set Obtain Release Walkto Create Delete Add Append Insert Prepend Remove Replace Read Write The suffixes are as follows: Handle -- when the prefix is Obtain or Release Page 6 Standard names for procedures make it easier to determine the function of a particular procedure from its name. An explanation for the choice of the naming conventions is given in the Appendix. _____________ 2.6.4 Function_Name - Defines conventions for naming functions and checks the declarations of functions to make sure they are adhered to. At present there are no predefined function prefixes or suffixes. Page 7 _________ ___________ ___ ______ ___________ 3 APPENDIX: EXPLANATION FOR NAMING CONVENTIONS ____ _____ 3.1 Type Names "...Number" An integer type, used to define the range of legal values for some kind of index, etc. For example, type ChannelNumber is range 1..400; "...Name" An enumeration type (or perhaps a string) used to identify a condition, parameter, item, object, etc. For example, type DianaNodeName is (dn_apply,...); "...Range" A subtype of one of the above. "...Task" A task type "...Record" A descriptor record of some kind "...Specifier" A descriptor record of some kind "...Descriptor" A descriptor record of some kind "...Handle" An access type to one of the above composite types, generally private "...Array" An array type "...String" A character array type "...Node" A record type used for nodes in a tree structure "...Ptr" An access type to a ...Array or ...Node "...Type" when none of the above _________ _____ 3.2 Procedure Names "Allocate..." A procedure which allocates a new ... "Free..." A procedure which frees an existing ... "Get..." A procedure which gives its result as an out parameter "Set..." A procedure which sets a value from an in parameter "Obtain...Handle" A procedure to return private handle as an out parameter given specifications of some existing object. Increment reference count. "Release...Handle" A procedure to decrement reference count and dispose of handle. Obtains and releases should match up. "WalkTo..." A procedure to take handle, and return handle on child, parent, sibling, etc, decrementing ref count of input handle and incrementing ref count of output handle. "Create..." A procedure to create a new object "Delete..." A procedure to delete an object "Add..." A procedure to add a new element to list, table, etc. "Append..." A procedure to add a new element at the end of a list, etc. "Insert..." A procedure to add a new element in the middle of a list, etc. "Prepend..." A procedure to add to the beginning of a list, etc. "Remove..." A procedure to remove an element from a list, etc. "Replace..." A procedure to replace an existing element from a list, etc. "Read..." A procedure to read (part of) data from object "Write..." A procedure to overwrite (part of) data of object --:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: --userman.rno --:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: .FLAG BOLD .TAB STOP 8 .LEFT MARGIN 8 .RIGHT MARGIN 78 .HEADER LEVEL 1^*^&STANDARDS CHECKER\&\* .HEADER LEVEL 2^&Description\& .PARAGRAPH This tool checks Ada program library units for adherence to Ada programming standards. The standards to be checked are specified in a predefined standards package. .PARAGRAPH Note that there may be cases in which the use of non-standard constructs, names, etc. is justified; for example, it may be clearer to use a non-standard construct in some cases or it may sometimes actually be necessary. The messages produced by Check__Standards are only intended to point out portions of code which do not conform to standards. One may then decide whether the non-standard construct, organization, etc. is justified for the particular situation. .HEADER LEVEL 2^&Command Format\& .BLANK .LITERAL type PRINT_TYPE is (VIOLATION, SOURCE); type REPORT_TYPE is (EVERY, FIRST); CHECK_STANDARDS ( --| Check standards of input file SOURCE : in STRING; --| Name of the source input file OUTPUT : in STRING := ""; --| Name of an output file PRINT : in PRINT_TYPE := --| Type of output: with source VIOLATION; --| and violations or just --| violations REPORT : in REPORT_TYPE:= --| Type of report: all errors EVERY --| reported or just the first of --| each type of violation ); .END LITERAL .LEFT MARGIN 20 .TAB STOP 20 .INDENT -12 SOURCE The name of the source file to be checked. It must be syntactically correct or the tool will stop and report the syntax error. .INDENT -12 OUTPUT The name of a file in which to put the output. If the name is left blank the output will go to the standard output. An invalid file name will result in an error being reported. .INDENT -12 PRINT The type of output to put in the report. If this is VIOLATION only the violations will be reported with line numbers being indicated in the messages. If the print type is SOURCE then the output will include the text from the source file with the violations being reported in the source as they occur. .INDENT -12 REPORT This indicates how the violations are to be reported. It can either report every violation, or just the first one of each kind. .TAB STOP 8 .LEFT MARGIN 8 .HEADER LEVEL 2^&When the Standards are checked\& .PARAGRAPH Due to the character of the checks being performed it is not sensible to do all of the checks in all contexts. Checks for particular constructs can obviously only be checked for in the contexts on which they are legal. For example, a goto statement may only appear in a body. The following descriptions indicate when the checks will take place if it is not already obvious. .HEADER LEVEL 1^&Rationale for Standards\& .HEADER LEVEL 2^&Standards for Overall Organization\& .HEADER LEVEL 3^&Max__Nesting\& .PARAGRAPH Checks that procedures and functions are not nested. Since packages may be nested, subprogram nesting may be avoided. In this way, nesting to avoid parameter passing will be discouraged. .HEADER LEVEL 3^&Max__Ada__Statements\& .PARAGRAPH Checks that no single subprogram exceeds 100 statements. Long subprograms may indicate a lack of abstraction or misuse of control structures, especially in the case of exception handling, unnecessary repetition of code or mixing of functionality. Limiting the size of subprograms can help to reduce these problems. Statements are counted in the same way that the Statement__Profile tool counts them. .HEADER LEVEL 3^&Private__Types__Checking\& .PARAGRAPH Checks that non-scalar types defined in the visible part of a package are private or limited private types. Declaring the types as private introduces the concept of data abstraction by hiding the implementation of the type and providing a cleaner interface to it. The operations on a type will then be clearly defined, the type will be easier to use and the proper use of the type will be enforced. .HEADER LEVEL 2^&Standards for Particular Constructs\& .HEADER LEVEL 3^&Goto__Checking\& .PARAGRAPH Checks for explicit Gotos in the library. The harmful effects of Gotos are well known and need not be described here. .HEADER LEVEL 3^&Exit__When__Checking\& .PARAGRAPH Checks that "exit when ^&condition\&" is used rather than "if ^&condition\& exit" for exits from a loop. Again, enforces the use of the appropriate construct. .HEADER LEVEL 3^&Boolean__Test__Checking\& .PARAGRAPH Checks that no expressions of the form "if ^&boolean value\& = true" appear. Not only is this type of statement redundant and potentially confusing, but it may also cause unintended results because of precedence rules for equality. .HEADER LEVEL 2^&Standards for Parameter Passing\& .HEADER LEVEL 3^&Max__Args\& .PARAGRAPH Checks that the number of arguments to a subprogram does not exceed four. If several parameters are logically linked, it is sometimes possible to encapsulate them into a single data abstraction, passed as a single argument. This standard is checked in the visible part of any packages and for any subprogram body and specification. It is also necessary to check subprogram bodies because there may only be a body with an implicit spec, so the body will be the only place the tool is able to check it. .PAGE .HEADER LEVEL 2^&Standards to Enforce Portability\& .HEADER LEVEL 3^&Builtin__Types__Checking\& .PARAGRAPH Checks for occurrences of "integer" and other builtin types and subtypes. If builtin types are used explicitly, rather than defining a subtype as a subrange of the type, the code is no longer portable. In addition, run time bounds checking is provided. If a value is out of bounds, an exception will be raised. The use of subtypes may also reduce the amount of storage space necessary. This check is performed on all parts of a program. .HEADER LEVEL 3^&Acceptable__Pragmas\& .PARAGRAPH Checks that no pragmas other than the following are used anywhere in the program: .BLANK .LITERAL elaborate, page, inline .END LITERAL .BLANK Certain pragmas are not portable, and should thus be avoided if possible. .HEADER LEVEL 3^&Rep__Specs__Checking\& .PARAGRAPH Checks for the use of Rep Specs, which are not portable constructs. .HEADER LEVEL 3^&Code__Statement__Checking\& .PARAGRAPH Checks for the use of code statements, which are not portable constructs. .HEADER LEVEL 2^&Standards to Enforce Maintainability\& .HEADER LEVEL 3^&Named__Subtype__Checking\& .PARAGRAPH Checks that named subtypes are defined instead of using explicit range constraints in parameter or discriminant specifications. If named subtypes are defined, changes to the range values need only be made in one place. The descriptive names also provide additional documentation. This is checked everywhere but in subtype definitions. .HEADER LEVEL 3^&Named__Literal__Checking\& .PARAGRAPH Checks that named literals are defined. Unnamed literals like "27" should only appear in "named number" declarations. A comment should justify the particular value, indicating other possible values if later adjustment is possible. Again, if the value is to be changed later, it is only necessary to change it in one place. The names also provide additional documentation. It does however, seem reasonable that certain numbers like "1" can be exempt. The numbers presently exempt are "0,1,2", but these can be changed. This check is done in all bodies. .HEADER LEVEL 2^&Naming Standards\& .HEADER LEVEL 3^&Type__Name\& .PARAGRAPH Defines conventions for naming types and checks visible parts to make sure these conventions are adhered to for type definitions. Currently, no standard prefixes are defined; the standard suffixes are as follows: .BLANK .LITERAL Number Name Range Task Record Specifier Descriptor Handle Array String Node Ptr Type .END LITERAL .BLANK Defining prefixes and suffixes for types helps to distinguish between types and objects, as well as providing documentation in the names and standardizing style. Note that certain suffixes are logical for different types, and that it wouldn't make sense to name something xRecord if it wasn't a record. The tool does check that the proper suffixes are used with the type of definition it is. For a fuller description of the suffixes see the appendix. This check is performed on all type declarations. .HEADER LEVEL 3^&Package__Name\& .PARAGRAPH Defines conventions for naming packages and checks packages to make sure these conventions are adhered to. Currently, no standard package names are defined. Standard names for packages make it easier to determine the function of a particular package from its name. This check is only done on package specs as we don't want to report things twice if we don't have to. .HEADER LEVEL 3^&Procedure__Name\& .PARAGRAPH Defines conventions for naming procedures and checks procedures to make sure these conventions are adhered to. Currently the prefixes defined are as follows: .LITERAL Allocate Free Get Set Obtain Release Walkto Create Delete Add Append Insert Prepend Remove Replace Read Write .END LITERAL The suffixes are as follows: .LITERAL Handle -- when the prefix is Obtain or Release .END LITERAL Standard names for procedures make it easier to determine the function of a particular procedure from its name. An explanation for the choice of the naming conventions is given in the Appendix. .HEADER LEVEL 3^&Function__Name\& .PARAGRAPH Defines conventions for naming functions and checks the declarations of functions to make sure they are adhered to. At present there are no predefined function prefixes or suffixes. .PAGE .HEADER LEVEL 1^&Appendix: Explanation for Naming Conventions\& .HEADER LEVEL 2^&Type Names\& .BLANK .LEFT MARGIN 20 .TAB STOP 20 .INDENT -15 "...Number" An integer type, used to define the range of legal values for some kind of index, etc. For example, type ChannelNumber is range 1..400; .INDENT -15 "...Name" An enumeration type (or perhaps a string) used to identify a condition, parameter, item, object, etc. For example, type DianaNodeName is (dn__apply,...); .INDENT -15 "...Range" A subtype of one of the above. .INDENT -15 "...Task" A task type .INDENT -15 "...Record" A descriptor record of some kind .INDENT -15 "...Specifier" A descriptor record of some kind .INDENT -15 "...Descriptor" A descriptor record of some kind .INDENT -15 "...Handle" An access type to one of the above composite types, generally private .INDENT -15 "...Array" An array type .INDENT -15 "...String" A character array type .INDENT -15 "...Node" A record type used for nodes in a tree structure .INDENT -15 "...Ptr" An access type to a ...Array or ...Node .INDENT -15 "...Type" when none of the above .TAB STOP 8 .LEFT MARGIN 8 .HEADER LEVEL 2^&Procedure Names\& .LEFT MARGIN 20 .TAB STOP 20 .INDENT -15 "Allocate..." A procedure which allocates a new ... .INDENT -15 "Free..." A procedure which frees an existing ... .INDENT -15 "Get..." A procedure which gives its result as an out parameter .INDENT -15 "Set..." A procedure which sets a value from an in parameter .INDENT -15 "Obtain...Handle" A procedure to return private handle as an out parameter given specifications of some existing object. Increment reference count. .INDENT -15 "Release...Handle" A procedure to decrement reference count and dispose of handle. Obtains and releases should match up. .INDENT -15 "WalkTo..." A procedure to take handle, and return handle on child, parent, sibling, etc, decrementing ref count of input handle and incrementing ref count of output handle. .INDENT -15 "Create..." A procedure to create a new object .INDENT -15 "Delete..." A procedure to delete an object .INDENT -15 "Add..." A procedure to add a new element to list, table, etc. .INDENT -15 "Append..." A procedure to add a new element at the end of a list, etc. .INDENT -15 "Insert..." A procedure to add a new element in the middle of a list, etc. .INDENT -15 "Prepend..." A procedure to add to the beginning of a list, etc. .INDENT -15 "Remove..." A procedure to remove an element from a list, etc. .INDENT -15 "Replace..." A procedure to replace an existing element from a list, etc. .INDENT -15 "Read..." A procedure to read (part of) data from object .INDENT -15 "Write..." A procedure to overwrite (part of) data of object .TAB STOP 8 .LEFT MARGIN 8 .PAGE --:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: --release.nts --:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: This is the first release of the standards checker. --:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: --stdckgrm.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 235 Number of Rules 488 Number of Items 1648 Number of states 949 Number of shift entries 1540 Number of goto entries 2173 Number of reduce entries 158 Number of entries saved by default reductions 5681 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 pragma_identifier ( general_component_associations ) ; 2 pragma ::= PRAGMA pragma_identifier ; 3 pragma_identifier ::= 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 ::= object_item ; 16 object_item ::= identifier_list : subtype_indication [:=expression] 17 object_item ::= identifier_list : CONSTANT subtype_indication [:=expression] 18 object_item ::= identifier_list : constrained_array_definition [:=expression] 19 object_item ::= identifier_list : CONSTANT constrained_array_definition [:=expression] 20 number_declaration ::= identifier_list : CONSTANT := expression ; 21 identifier_list ::= identifier {,identifier} 22 type_declaration ::= full_type_declaration 23 type_declaration ::= incomplete_type_declaration 24 type_declaration ::= private_type_declaration 25 full_type_declaration ::= TYPE type_identifier is__type_definition ; 26 full_type_declaration ::= TYPE type_identifier ( discriminant_specification {;discriminant_specification} ) is__type_definition ; 27 is__type_definition ::= IS type_definition 28 type_identifier ::= identifier 29 type_definition ::= enumeration_type_definition 30 type_definition ::= integer_type_definition 31 type_definition ::= real_type_definition 32 type_definition ::= array_type_definition 33 type_definition ::= record_type_definition 34 type_definition ::= access_type_definition 35 type_definition ::= derived_type_definition 36 subtype_declaration ::= SUBTYPE type_identifier is__subtype_indication ; 37 is__subtype_indication ::= IS subtype_indication 38 subtype_indication ::= type_mark 39 subtype_indication ::= type_mark constraint 40 type_mark ::= type_name|subtype_name 41 constraint ::= range_constraint 42 constraint ::= floating_point_constraint 43 constraint ::= fixed_point_constraint 44 constraint ::= ( general_component_associations ) 45 derived_type_definition ::= NEW subtype_indication 46 range_constraint ::= RANGE simple_expression 47 range_constraint ::= RANGE simple_expression .. simple_expression 48 enumeration_type_definition ::= ( enumeration_literal_specification {,enumeration_literal_specification} ) 49 enumeration_literal_specification ::= enumeration_literal 50 enumeration_literal ::= identifier 51 enumeration_literal ::= character_literal 52 integer_type_definition ::= range_constraint 53 real_type_definition ::= floating_point_constraint 54 real_type_definition ::= fixed_point_constraint 55 floating_point_constraint ::= floating_accuracy_definition [range_constraint] 56 floating_accuracy_definition ::= DIGITS simple_expression 57 fixed_point_constraint ::= fixed_accuracy_definition [range_constraint] 58 fixed_accuracy_definition ::= DELTA simple_expression 59 array_type_definition ::= unconstrained_array_definition 60 array_type_definition ::= constrained_array_definition 61 unconstrained_array_definition ::= ARRAY ( index_subtype_definition {,index_subtype_definition} ) OF subtype_indication 62 constrained_array_definition ::= ARRAY index_constraint OF subtype_indication 63 index_subtype_definition ::= name RANGE <> 64 index_constraint ::= ( discrete_range {,discrete_range} ) 65 discrete_range ::= name range_constraint 66 discrete_range ::= range 67 range ::= simple_expression 68 range ::= simple_expression .. simple_expression 69 record_type_definition ::= RECORD component_list END RECORD 70 component_list ::= {pragma_decl} {component_declaration} component_declaration {pragma_decl} 71 component_list ::= {pragma_decl} {component_declaration} variant_part {pragma_decl} 72 component_list ::= NULL ; {pragma_decl} 73 component_declaration ::= component_item ; 74 component_item ::= identifier_list : subtype_indication [:=expression] 75 discriminant_specification ::= identifier_list : type_mark [:=expression] 76 variant_part ::= CASE identifier IS {pragma_variant} variant {variant} END CASE ; 77 variant ::= WHEN choice {|choice} => component_list 78 variant ::= WHEN OTHERS => component_list 79 choice ::= simple_expression 80 choice ::= simple_expression .. simple_expression 81 choice ::= name range_constraint 82 access_type_definition ::= ACCESS subtype_indication 83 incomplete_type_declaration ::= TYPE type_identifier ; 84 incomplete_type_declaration ::= TYPE type_identifier ( discriminant_specification {;discriminant_specification} ) ; 85 declarative_part ::= {basic_declarative_item} 86 declarative_part ::= {basic_declarative_item} body {later_declarative_item} 87 basic_declarative_item ::= basic_declaration 88 basic_declarative_item ::= representation_clause 89 basic_declarative_item ::= use_clause 90 later_declarative_item ::= body 91 later_declarative_item ::= subprogram_declaration 92 later_declarative_item ::= package_declaration 93 later_declarative_item ::= task_declaration 94 later_declarative_item ::= generic_declaration 95 later_declarative_item ::= use_clause 96 later_declarative_item ::= generic_instantiation 97 body ::= proper_body 98 body ::= body_stub 99 proper_body ::= subprogram_body 100 proper_body ::= package_body 101 proper_body ::= task_body 102 name ::= identifier 103 name ::= character_literal 104 name ::= string_literal 105 name ::= indexed_component 106 name ::= selected_component 107 name ::= attribute 108 indexed_component ::= name ( general_component_associations ) 109 selected_component ::= name . selector 110 selected_component ::= name . ALL 111 selector ::= identifier 112 selector ::= character_literal 113 selector ::= string_literal 114 attribute ::= name ' attribute_designator 115 attribute_designator ::= identifier 116 attribute_designator ::= DIGITS 117 attribute_designator ::= DELTA 118 attribute_designator ::= RANGE 119 aggregate ::= ( component_associations ) 120 component_associations ::= expression,expression{,expression} [,others=>expression] 121 component_associations ::= expression,expression{,expression} , choice{|choice}=>expression {,choice{|choice}=>expression} [,others=>expression] 122 component_associations ::= expression , choice{|choice}=>expression {,choice{|choice}=>expression} [,others=>expression] 123 component_associations ::= choice{|choice}=>expression {,choice{|choice}=>expression} [,others=>expression] 124 component_associations ::= expression , others=>expression 125 component_associations ::= others=>expression 126 general_component_associations ::= ga_expression{,ga_expression} 127 general_component_associations ::= ga_expression{,ga_expression} , identifier{|identifier}=>expression {,identifier{|identifier}=>expression} 128 general_component_associations ::= identifier{|identifier}=>expression {,identifier{|identifier}=>expression} 129 expression ::= relation 130 expression ::= relation{AND__relation} 131 expression ::= relation{OR__relation} 132 expression ::= relation{XOR__relation} 133 expression ::= relation{AND__THEN__relation} 134 expression ::= relation{OR__ELSE__relation} 135 relation ::= simple_expression [relational_operator__simple_expression] 136 relation ::= simple_expression [NOT]IN range 137 simple_expression ::= [unary_adding_operator]term{binary_adding_operator__term} 138 term ::= factor{multiplying_operator__factor} 139 factor ::= primary [exponentiating_operator__primary] 140 factor ::= high_precedence_unary_operator primary 141 parenthesized_expression ::= ( expression ) 142 primary ::= numeric_literal 143 primary ::= NULL 144 primary ::= name 145 primary ::= allocator 146 primary ::= qualified_expression 147 primary ::= aggregate 148 primary ::= parenthesized_expression 149 relational_operator ::= = 150 relational_operator ::= /= 151 relational_operator ::= < 152 relational_operator ::= <= 153 relational_operator ::= > 154 relational_operator ::= >= 155 binary_adding_operator ::= + 156 binary_adding_operator ::= - 157 binary_adding_operator ::= & 158 unary_adding_operator ::= + 159 unary_adding_operator ::= - 160 high_precedence_unary_operator ::= ABS 161 high_precedence_unary_operator ::= NOT 162 multiplying_operator ::= * 163 multiplying_operator ::= / 164 multiplying_operator ::= MOD 165 multiplying_operator ::= REM 166 exponentiating_operator ::= ** 167 qualified_expression ::= name ' aggregate 168 qualified_expression ::= name ' parenthesized_expression 169 allocator ::= NEW type_mark 170 allocator ::= NEW type_mark ( general_component_associations ) 171 allocator ::= NEW expanded_name ' parenthesized_expression 172 allocator ::= NEW expanded_name ' aggregate 173 sequence_of_statements ::= {pragma_stm} statement {statement} 174 statement ::= simple_statement 175 statement ::= compound_statement 176 statement ::= {label}+ simple_statement 177 statement ::= {label}+ compound_statement 178 simple_statement ::= null_statement 179 simple_statement ::= assignment_statement 180 simple_statement ::= exit_statement 181 simple_statement ::= return_statement 182 simple_statement ::= goto_statement 183 simple_statement ::= delay_statement 184 simple_statement ::= abort_statement 185 simple_statement ::= raise_statement 186 simple_statement ::= code_statement 187 simple_statement ::= call_statement 188 compound_statement ::= if_statement 189 compound_statement ::= case_statement 190 compound_statement ::= loop_statement 191 compound_statement ::= block_statement 192 compound_statement ::= accept_statement 193 compound_statement ::= select_statement 194 label ::= << identifier >> 195 null_statement ::= NULL ; 196 assignment_statement ::= name := expression ; 197 if_statement ::= IF condition_THEN__sequence_of_statements {ELSIF__condition__THEN__sequence_of_statements} [ELSE__sequence_of_statements] END IF ; 198 condition ::= expression 199 case_statement ::= CASE expression IS {pragma_alt} case_statement_alternative {case_statement_alternative} END CASE ; 200 case_statement_alternative ::= WHEN choice {|choice} => sequence_of_statements 201 case_statement_alternative ::= WHEN OTHERS => sequence_of_statements 202 loop_statement ::= [loop_identifier:] LOOP sequence_of_statements END LOOP [identifier] ; 203 loop_statement ::= [loop_identifier:] iteration_rule LOOP sequence_of_statements END LOOP [identifier] ; 204 iteration_rule ::= WHILE condition 205 iteration_rule ::= FOR identifier IN discrete_range 206 iteration_rule ::= FOR identifier IN REVERSE discrete_range 207 declarative_part__begin_end_block ::= declarative_part begin_end_block 208 begin_end_block ::= begin_end_block_head sequence_of_statements END 209 begin_end_block ::= begin_end_block_head sequence_of_statements EXCEPTION {pragma_alt}__exception_handler_list END 210 begin_end_block_head ::= BEGIN 211 block_statement ::= [block_identifier:] declare_item declarative_part__begin_end_block [identifier] ; 212 block_statement ::= [block_identifier:] begin_end_block [identifier] ; 213 declare_item ::= DECLARE 214 exit_statement ::= exit_item ; 215 exit_item ::= EXIT 216 exit_item ::= EXIT WHEN condition 217 exit_item ::= EXIT expanded_name 218 exit_item ::= EXIT expanded_name WHEN condition 219 return_statement ::= RETURN ; 220 return_statement ::= RETURN expression ; 221 goto_statement ::= goto_item ; 222 goto_item ::= GOTO expanded_name 223 subprogram_declaration ::= subprogram_specification ; 224 subprogram_specification ::= PROCEDURE subprogram_identifier 225 subprogram_specification ::= PROCEDURE subprogram_identifier ( parameter_specification {;parameter_specification} ) 226 subprogram_specification ::= FUNCTION designator RETURN type_mark 227 subprogram_specification ::= FUNCTION designator ( parameter_specification {;parameter_specification} ) RETURN type_mark 228 designator ::= identifier 229 designator ::= string_literal 230 subprogram_identifier ::= identifier 231 parameter_specification ::= identifier_list mode type_mark [:=expression] 232 mode ::= generic_parameter_mode 233 mode ::= : OUT 234 generic_parameter_mode ::= : 235 generic_parameter_mode ::= : IN 236 generic_parameter_mode ::= : IN OUT 237 subprogram_body ::= subprogram_body_head subprogram_body_tail 238 subprogram_body_head ::= subprogram_specification IS 239 subprogram_body_tail ::= declarative_part__begin_end_block [end_designator] ; 240 call_statement ::= name ; 241 package_declaration ::= package_specification ; 242 package_specification ::= PACKAGE package_identifier IS {basic_declarative_item} END [identifier] 243 package_specification ::= PACKAGE package_identifier IS {basic_declarative_item} private_part {basic_declarative_item} END [identifier] 244 private_part ::= PRIVATE 245 package_identifier ::= identifier 246 package_body ::= package_body_indicator declarative_part END [identifier] ; 247 package_body ::= package_body_indicator declarative_part__begin_end_block [identifier] ; 248 package_body_indicator ::= PACKAGE BODY identifier IS 249 private_type_declaration ::= TYPE type_identifier IS LIMITED PRIVATE ; 250 private_type_declaration ::= TYPE type_identifier ( discriminant_specification {;discriminant_specification} ) IS LIMITED PRIVATE ; 251 private_type_declaration ::= TYPE type_identifier IS PRIVATE ; 252 private_type_declaration ::= TYPE type_identifier ( discriminant_specification {;discriminant_specification} ) IS PRIVATE ; 253 use_clause ::= USE expanded_name {,expanded_name} ; 254 renaming_declaration ::= identifier_list : type_mark RENAMES name ; 255 renaming_declaration ::= identifier_list : EXCEPTION RENAMES expanded_name ; 256 renaming_declaration ::= PACKAGE package_identifier RENAMES expanded_name ; 257 renaming_declaration ::= subprogram_specification RENAMES name ; 258 task_declaration ::= task_specification ; 259 task_specification ::= TASK task_identifier 260 task_specification ::= TASK TYPE task_identifier 261 task_specification ::= TASK task_identifier IS {entry_declaration} {representation_clause} END [identifier] 262 task_specification ::= TASK TYPE task_identifier IS {entry_declaration} {representation_clause} END [identifier] 263 task_identifier ::= identifier 264 task_body ::= task_body_indicator declarative_part__begin_end_block [identifier] ; 265 task_body_indicator ::= TASK BODY identifier IS 266 entry_declaration ::= ENTRY identifier [(discrete_range)][formal_part] ; 267 accept_statement ::= ACCEPT identifier [(expression)][formal_part] ; 268 accept_statement ::= ACCEPT identifier [(expression)][formal_part] DO sequence_of_statements END [identifier] ; 269 delay_statement ::= DELAY simple_expression ; 270 select_statement ::= selective_wait 271 select_statement ::= conditional_entry_call 272 select_statement ::= timed_entry_call 273 selective_wait ::= SELECT select_alternative {OR__select_alternative} [ELSE__sequence_of_statements] END SELECT ; 274 select_alternative ::= {pragma_stm} WHEN condition => selective_wait_alternative 275 select_alternative ::= {pragma_stm} selective_wait_alternative 276 selective_wait_alternative ::= accept_alternative 277 selective_wait_alternative ::= delay_alternative 278 selective_wait_alternative ::= terminate_alternative 279 accept_alternative ::= accept_statement [sequence_of_statements] 280 delay_alternative ::= delay_statement [sequence_of_statements] 281 terminate_alternative ::= TERMINATE ; {pragma_stm} 282 conditional_entry_call ::= SELECT {pragma_stm} call_statement [sequence_of_statements] ELSE sequence_of_statements END SELECT ; 283 timed_entry_call ::= SELECT {pragma_stm} call_statement [sequence_of_statements] OR {pragma_stm} delay_alternative END SELECT ; 284 abort_statement ::= ABORT name {,name} ; 285 compilation ::= {compilation_unit} 286 pragma_header ::= PRAGMA pragma_identifier 287 compilation_unit ::= pragma_header ( general_component_associations ) ; 288 compilation_unit ::= pragma_header ; 289 compilation_unit ::= context_clause library_or_secondary_unit 290 library_or_secondary_unit ::= subprogram_declaration 291 library_or_secondary_unit ::= package_declaration 292 library_or_secondary_unit ::= generic_declaration 293 library_or_secondary_unit ::= generic_instantiation 294 library_or_secondary_unit ::= subprogram_body 295 library_or_secondary_unit ::= package_body 296 library_or_secondary_unit ::= subunit 297 context_clause ::= {with_clause{use_clause}} 298 with_clause ::= WITH identifier {,used_identifier} ; 299 body_stub ::= subprogram_specification IS SEPARATE ; 300 body_stub ::= PACKAGE BODY identifier IS SEPARATE ; 301 body_stub ::= TASK BODY identifier IS SEPARATE ; 302 subunit ::= SEPARATE ( expanded_name ) proper_body 303 exception_declaration ::= identifier_list : EXCEPTION ; 304 exception_handler ::= WHEN exception_choice {|exception_choice} => sequence_of_statements 305 exception_choice ::= expanded_name 306 exception_choice ::= OTHERS 307 raise_statement ::= RAISE ; 308 raise_statement ::= RAISE expanded_name ; 309 generic_declaration ::= generic_specification ; 310 generic_specification ::= generic_formal_part subprogram_specification 311 generic_specification ::= generic_formal_part package_specification 312 generic_formal_part ::= GENERIC {generic_parameter_declaration} 313 generic_parameter_declaration ::= identifier_list generic_parameter_mode type_mark [:=expression] ; 314 generic_parameter_declaration ::= TYPE type_identifier IS generic_type_definition ; 315 generic_parameter_declaration ::= TYPE type_identifier ( discriminant_specification {;discriminant_specification} ) IS generic_type_definition ; 316 generic_parameter_declaration ::= WITH subprogram_specification [IS__name__or__<>] ; 317 generic_type_definition ::= ( <> ) 318 generic_type_definition ::= RANGE <> 319 generic_type_definition ::= DIGITS <> 320 generic_type_definition ::= DELTA <> 321 generic_type_definition ::= LIMITED PRIVATE 322 generic_type_definition ::= PRIVATE 323 generic_type_definition ::= array_type_definition 324 generic_type_definition ::= access_type_definition 325 generic_instantiation ::= PACKAGE package_identifier IS NEW expanded_name ; 326 generic_instantiation ::= PACKAGE package_identifier IS NEW expanded_name ( generic_association {,generic_association} ) ; 327 generic_instantiation ::= FUNCTION designator IS NEW expanded_name ; 328 generic_instantiation ::= FUNCTION designator IS NEW expanded_name ( generic_association {,generic_association} ) ; 329 generic_instantiation ::= subprogram_specification IS NEW expanded_name ; 330 generic_instantiation ::= subprogram_specification IS NEW expanded_name ( generic_association {,generic_association} ) ; 331 generic_association ::= [generic_formal_parameter=>]generic_actual_parameter 332 generic_formal_parameter ::= identifier 333 generic_formal_parameter ::= string_literal 334 generic_actual_parameter ::= expression 335 representation_clause ::= representation_item ; 336 representation_item ::= length_clause 337 representation_item ::= enumeration_representation_clause 338 representation_item ::= address_clause 339 representation_item ::= record_representation_clause 340 length_clause ::= FOR attribute USE simple_expression 341 enumeration_representation_clause ::= FOR identifier USE aggregate 342 record_representation_clause ::= FOR identifier USE RECORD {component_clause} END RECORD 343 record_representation_clause ::= FOR identifier USE RECORD alignment_clause {component_clause} END RECORD 344 component_clause ::= name AT simple_expression range_constraint ; 345 alignment_clause ::= AT MOD simple_expression ; 346 address_clause ::= FOR identifier USE AT simple_expression 347 code_statement ::= code_item ; 348 code_item ::= name ' aggregate 349 {pragma_decl} ::= EMPTY 350 {pragma_decl} ::= {pragma_decl} pragma 351 {pragma_variant} ::= EMPTY 352 {pragma_variant} ::= {pragma_variant} pragma 353 {pragma_stm} ::= EMPTY 354 {pragma_stm} ::= {pragma_stm} pragma 355 {pragma_alt} ::= EMPTY 356 {pragma_alt} ::= {pragma_alt} pragma 357 [:=expression] ::= EMPTY 358 [:=expression] ::= := expression 359 {,identifier} ::= EMPTY 360 {,identifier} ::= {,identifier} , identifier 361 type_name|subtype_name ::= expanded_name 362 expanded_name ::= identifier 363 expanded_name ::= expanded_name . identifier 364 {,enumeration_literal_specification} ::= EMPTY 365 {,enumeration_literal_specification} ::= {,enumeration_literal_specification} , enumeration_literal_specification 366 [range_constraint] ::= EMPTY 367 [range_constraint] ::= range_constraint 368 {,index_subtype_definition} ::= EMPTY 369 {,index_subtype_definition} ::= {,index_subtype_definition} , index_subtype_definition 370 {,discrete_range} ::= EMPTY 371 {,discrete_range} ::= {,discrete_range} , discrete_range 372 {component_declaration} ::= EMPTY 373 {component_declaration} ::= {component_declaration} component_declaration {pragma_decl} 374 {;discriminant_specification} ::= EMPTY 375 {;discriminant_specification} ::= {;discriminant_specification} ; discriminant_specification 376 {variant} ::= EMPTY 377 {variant} ::= {variant} variant 378 {|choice} ::= EMPTY 379 {|choice} ::= {|choice} '|' choice 380 {basic_declarative_item} ::= {pragma_decl} 381 {basic_declarative_item} ::= {basic_declarative_item} basic_declarative_item {pragma_decl} 382 {later_declarative_item} ::= {pragma_decl} 383 {later_declarative_item} ::= {later_declarative_item} later_declarative_item {pragma_decl} 384 expression,expression{,expression} ::= expression , expression 385 expression,expression{,expression} ::= expression,expression{,expression} , expression 386 choice{|choice}=>expression ::= choice {|choice} => expression 387 {,choice{|choice}=>expression} ::= EMPTY 388 {,choice{|choice}=>expression} ::= {,choice{|choice}=>expression} , choice{|choice}=>expression 389 [,others=>expression] ::= EMPTY 390 [,others=>expression] ::= , others=>expression 391 others=>expression ::= OTHERS => expression 392 ga_expression ::= expression 393 ga_expression ::= simple_expression .. simple_expression 394 ga_expression ::= name range_constraint 395 ga_expression{,ga_expression} ::= ga_expression 396 ga_expression{,ga_expression} ::= ga_expression{,ga_expression} , ga_expression 397 identifier{|identifier}=>expression ::= identifier {|identifier} => expression 398 {,identifier{|identifier}=>expression} ::= EMPTY 399 {,identifier{|identifier}=>expression} ::= {,identifier{|identifier}=>expression} , identifier{|identifier}=>expression 400 {|identifier} ::= EMPTY 401 {|identifier} ::= {|identifier} '|' identifier 402 relation{AND__relation} ::= relation AND relation 403 relation{AND__relation} ::= relation{AND__relation} AND relation 404 relation{OR__relation} ::= relation OR relation 405 relation{OR__relation} ::= relation{OR__relation} OR relation 406 relation{XOR__relation} ::= relation XOR relation 407 relation{XOR__relation} ::= relation{XOR__relation} XOR relation 408 relation{AND__THEN__relation} ::= relation AND THEN relation 409 relation{AND__THEN__relation} ::= relation{AND__THEN__relation} AND THEN relation 410 relation{OR__ELSE__relation} ::= relation OR ELSE relation 411 relation{OR__ELSE__relation} ::= relation{OR__ELSE__relation} OR ELSE relation 412 [relational_operator__simple_expression] ::= EMPTY 413 [relational_operator__simple_expression] ::= relational_operator simple_expression 414 [NOT]IN ::= IN 415 [NOT]IN ::= NOT IN 416 [unary_adding_operator]term{binary_adding_operator__term} ::= term 417 [unary_adding_operator]term{binary_adding_operator__term} ::= unary_adding_operator term 418 [unary_adding_operator]term{binary_adding_operator__term} ::= [unary_adding_operator]term{binary_adding_operator__term} binary_adding_operator term 419 factor{multiplying_operator__factor} ::= factor 420 factor{multiplying_operator__factor} ::= factor{multiplying_operator__factor} multiplying_operator factor 421 [exponentiating_operator__primary] ::= EMPTY 422 [exponentiating_operator__primary] ::= exponentiating_operator primary 423 {statement} ::= {pragma_stm} 424 {statement} ::= {statement} statement {pragma_stm} 425 {label}+ ::= label 426 {label}+ ::= {label}+ label 427 condition_THEN__sequence_of_statements ::= condition THEN sequence_of_statements 428 {ELSIF__condition__THEN__sequence_of_statements} ::= EMPTY 429 {ELSIF__condition__THEN__sequence_of_statements} ::= {ELSIF__condition__THEN__sequence_of_statements} ELSIF condition THEN sequence_of_statements 430 [ELSE__sequence_of_statements] ::= EMPTY 431 [ELSE__sequence_of_statements] ::= ELSE sequence_of_statements 432 {case_statement_alternative} ::= EMPTY 433 {case_statement_alternative} ::= {case_statement_alternative} case_statement_alternative 434 [loop_identifier:] ::= EMPTY 435 [loop_identifier:] ::= identifier : 436 [identifier] ::= EMPTY 437 [identifier] ::= identifier 438 [block_identifier:] ::= EMPTY 439 [block_identifier:] ::= identifier : 440 {pragma_alt}__exception_handler_list ::= {pragma_alt} exception_handler_list 441 exception_handler_list ::= exception_handler 442 exception_handler_list ::= exception_handler_list exception_handler 443 {;parameter_specification} ::= EMPTY 444 {;parameter_specification} ::= {;parameter_specification} ; parameter_specification 445 [end_designator] ::= EMPTY 446 [end_designator] ::= identifier 447 [end_designator] ::= string_literal 448 {,expanded_name} ::= EMPTY 449 {,expanded_name} ::= {,expanded_name} , expanded_name 450 {entry_declaration} ::= {pragma_decl} 451 {entry_declaration} ::= {entry_declaration} entry_declaration {pragma_decl} 452 {representation_clause} ::= EMPTY 453 {representation_clause} ::= {representation_clause} representation_clause {pragma_decl} 454 [(discrete_range)][formal_part] ::= EMPTY 455 [(discrete_range)][formal_part] ::= ( parameter_specification {;parameter_specification} ) 456 [(discrete_range)][formal_part] ::= ( discrete_range ) 457 [(discrete_range)][formal_part] ::= ( discrete_range ) ( parameter_specification {;parameter_specification} ) 458 [(expression)][formal_part] ::= EMPTY 459 [(expression)][formal_part] ::= ( parameter_specification {;parameter_specification} ) 460 [(expression)][formal_part] ::= ( expression ) 461 [(expression)][formal_part] ::= ( expression ) ( parameter_specification {;parameter_specification} ) 462 {OR__select_alternative} ::= EMPTY 463 {OR__select_alternative} ::= {OR__select_alternative} OR select_alternative 464 [sequence_of_statements] ::= {pragma_stm} 465 [sequence_of_statements] ::= sequence_of_statements 466 {,name} ::= EMPTY 467 {,name} ::= {,name} , name 468 {compilation_unit} ::= compilation_unit 469 {compilation_unit} ::= {compilation_unit} compilation_unit 470 {with_clause{use_clause}} ::= EMPTY 471 {with_clause{use_clause}} ::= {with_clause{use_clause}} with_clause use_clause_list 472 use_clause_list ::= {pragma_decl} 473 use_clause_list ::= use_clause_list use_clause {pragma_decl} 474 {,used_identifier} ::= EMPTY 475 {,used_identifier} ::= {,used_identifier} , identifier 476 {|exception_choice} ::= EMPTY 477 {|exception_choice} ::= {|exception_choice} '|' exception_choice 478 {generic_parameter_declaration} ::= EMPTY 479 {generic_parameter_declaration} ::= {generic_parameter_declaration} generic_parameter_declaration 480 [IS__name__or__<>] ::= EMPTY 481 [IS__name__or__<>] ::= IS name 482 [IS__name__or__<>] ::= IS <> 483 {,generic_association} ::= EMPTY 484 {,generic_association} ::= {,generic_association} , generic_association 485 [generic_formal_parameter=>]generic_actual_parameter ::= generic_actual_parameter 486 [generic_formal_parameter=>]generic_actual_parameter ::= generic_formal_parameter => generic_actual_parameter 487 {component_clause} ::= {pragma_decl} 488 {component_clause} ::= {component_clause} component_clause {pragma_decl} 1Non terminalss $ACC compilation pragma_identifier 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 object_item identifier_list subtype_indication [:=expression] constrained_array_definition expression {,identifier} full_type_declaration incomplete_type_declaration private_type_declaration type_identifier is__type_definition discriminant_specification {;discriminant_specification} type_definition enumeration_type_definition integer_type_definition real_type_definition array_type_definition record_type_definition access_type_definition derived_type_definition is__subtype_indication 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 component_item {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 begin_end_block_head {pragma_alt}__exception_handler_list [block_identifier:] declare_item exit_item goto_item subprogram_specification subprogram_identifier parameter_specification {;parameter_specification} designator mode generic_parameter_mode subprogram_body_head subprogram_body_tail [end_designator] package_specification package_identifier private_part package_body_indicator {,expanded_name} task_specification task_identifier {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 representation_item length_clause enumeration_representation_clause address_clause record_representation_clause {component_clause} alignment_clause component_clause code_item ga_expression {|identifier} exception_handler_list use_clause_list 1Information about Action Tables Number of Entries 3871 Origin Table Size 5531 Action Table Size 8217 Number Unused 2678 Distribution of entries 2017 671 143 17 3 0 0 0 1Timing Statistics Cpu Time Elapsed LG Reads LG Writes Parse: 11129 11129 0 36 Preliminary: 330 331 0 72 First Map: 1949 1949 0 7 Item Creation: 1325 1325 0 10 Follow Map: 1060 1061 0 0 Closure: 1008 1008 0 0 States: 10192 10191 0 310 Reductions: 10497 10497 0 88 Summary: 1347 1347 0 0 Compress: 2642 2642 0 77 Table Dump: 2026 2025 0 0 --:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: --standards.cnt --:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: [NOSC.RELEASES.V0101.STANDARDS]GRMCONST.BDY 32 31 [NOSC.RELEASES.V0101.STANDARDS]PTBLS.BDY 32102 3565 [NOSC.RELEASES.V0101.STANDARDS]SCUTILS.SPC 43 164 [NOSC.RELEASES.V0101.STANDARDS]SCDECLS.DAT 544 345 [NOSC.RELEASES.V0101.STANDARDS]SCUTILS.BDY 542 472 [NOSC.RELEASES.V0101.STANDARDS]STNDCHECK.ADA 305 224 [NOSC.RELEASES.V0101.STANDARDS]APPLYACT.SUB 305 1090 [NOSC.RELEASES.V0101.STANDARDS]GETNEXT.SUB 16 22 [NOSC.RELEASES.V0101.STANDARDS]WRITELINE.SUB 34 30