DataMuseum.dk

Presents historical artifacts from the history of:

Rational R1000/400 Tapes

This is an automatic "excavation" of a thematic subset of
artifacts from Datamuseum.dk's BitArchive.

See our Wiki for more about Rational R1000/400 Tapes

Excavated with: AutoArchaeologist - Free & Open Source Software.


top - metrics - download
Index: B T

⟦9be327c13⟧ TextFile

    Length: 43455 (0xa9bf)
    Types: TextFile
    Names: »B«

Derivation

└─⟦180fe333a⟧ Bits:30000405 8mm tape, Rational 1000, SW CATALOG, 10_20_0
└─⟦180fe333a⟧ Bits:30000537 8mm tape, Rational 1000, SW Catalog 10_20_0
    └─⟦5cb1d1d7f⟧ »DATA« 
        └─⟦3b1ee7bd8⟧ 
            └─⟦this⟧ 

TextFile

separate (Parser)

procedure Apply_Actions (Rule_Number : in Pt.Lefthandsiderange) is

    -- all procedure calls in this unit are procedures in package
    -- Source_Instrumenter_Utilities

    use Source_Instrumenter_Utilities;

begin

    case Rule_Number is


        -------------------------------------------------------------------
        -- pragma ::= PRAGMA identifier ( general_component_associations ) ;

        when 1

             -------------------------------------------------------------------
             -- pragma ::= PRAGMA identifier ;

              | 2 =>

            New_Line;

            -------------------------------------------------------------------
            -- basic_declaration ::= type_declaration

        when 3 =>

            End_Type_Declaration;

            -------------------------------------------------------------------
            -- basic_colon_declaration ::= object_declaration

        when 11

             -------------------------------------------------------------------
             -- basic_colon_declaration ::= number_declaration

              | 12

             -------------------------------------------------------------------
             -- basic_colon_declaration ::= exception_declaration

              | 13

             -------------------------------------------------------------------
             -- basic_colon_declaration ::= renaming_colon_declaration

              | 14 =>

            New_Line;

            -------------------------------------------------------------------
            -- object_declaration ::= identifier_list : subtype_indication [:=expression] ;

        when 15 =>

            Set_Identifier_Mode (Read_Write);
            Process_Identifier_List (Object_List);

            -------------------------------------------------------------------
            -- object_declaration ::= identifier_list : CONSTANT subtype_indication ;

        when 16 =>

            Set_Identifier_Mode (Read_Only);
            Process_Identifier_List (Object_List);

            -------------------------------------------------------------------
            -- object_declaration ::= identifier_list : start_cad
            --     constrained_array_definition

        when 17 =>

            Set_Identifier_Mode (Read_Write);
            Process_Identifier_List (Object_List);

            -------------------------------------------------------------------
            -- object_declaration ::= identifier_list : CONSTANT start_cad end_cad ;

        when 18 =>

            Set_Identifier_Mode (Read_Only);
            Process_Identifier_List (Object_List);

            -------------------------------------------------------------------
            -- start_cad ::= empty

        when 19 =>

            Start_Anonymous_Array_Definition;

            -------------------------------------------------------------------
            -- number_declaration ::= identifier_list : CONSTANT := expression ;

        when 21 =>

            Set_Identifier_Mode (Read_Only);
            Process_Identifier_List (Object_List);

            -------------------------------------------------------------------
            -- save_identifier ::= identifier

        when 23 =>

            Add_Identifier_To_List;

            -------------------------------------------------------------------
            -- type_identifier ::= identifier

        when 29 =>

            Save_Type_Identifier;

            -------------------------------------------------------------------
            -- type_definition ::= array_type_definition ;

        when 33 =>

            -- temporary until array processing done --
            -- beware generic array type definitions --
            Start_Trace_Procedure (Array_Type);

            -------------------------------------------------------------------
            -- type_definition ::= record_type_definition ;

        when 34 =>

            Decrease_Indent;

            -- temporary until record processing done --
            Start_Trace_Procedure (Record_Type);

            -------------------------------------------------------------------
            -- type_definition ::= access_type_definition ;

        when 35 =>


            -- temporary:  beware generic access type definitions --
            Start_Trace_Procedure (Access_Type);

            -------------------------------------------------------------------
            -- type_mark ::= type_name|subtype_name

        when 40 =>

            End_Typemark;

            -------------------------------------------------------------------
            -- derived_type_definition ::= NEW start_expanded_name subtype_indication

        when 45 =>

            Start_Trace_Procedure (Derived_Type);

            -------------------------------------------------------------------
            -- enumeration_type_definition ::= ( enumeration_literal_specification )

        when 48 =>

            Start_Trace_Procedure (Enumeration_Type);

            -------------------------------------------------------------------
            -- integer_type_definition ::= range_constraint

        when 52 =>

            Start_Trace_Procedure (Integer_Type);

            -------------------------------------------------------------------
            -- real_type_definition ::= floating_point_constraint

        when 53 =>

            Start_Trace_Procedure (Float_Type);

            -------------------------------------------------------------------
            -- real_type_definition ::= fixed_point_constraint

        when 54 =>

            Start_Trace_Procedure (Fixed_Type);

            -------------------------------------------------------------------
            -- component_list ::= {pragma_decl} {component_declaration}
            --     component_declaration

        when
           70

           -------------------------------------------------------------------
           -- component_list ::= {pragma_decl} {component_declaration}' variant_part

            | 71 =>

            Decrease_Indent;

            -------------------------------------------------------------------
            -- component_list ::= null_statement {pragma_decl}

        when 72 =>

            -- buffering started at record_terminal so must print out
            Print_Colon_Declarations_Buffer;
            Decrease_Indent;

            -------------------------------------------------------------------
            -- component_declaration ::= identifier_list : subtype_indication
            --     [:=expression] ;

        when 73 =>

            New_Line;
            Process_Identifier_List (Record_Field_List);

            -------------------------------------------------------------------
            -- discriminant_specification ::= identifier_list : start_expanded_name
            --     type_mark

        when 74 =>

            Process_Identifier_List (Discriminant_List);

            -------------------------------------------------------------------
            -- variant_part ::= CASE__identifier__IS {pragma_variant}__variant__{variant}
            --     END

        when 75 =>

            New_Line;

            -------------------------------------------------------------------
            -- declarative_part ::= start_bdi {basic_declarative_item}

        when 85

             -------------------------------------------------------------------
             -- declarative_part ::= start_bdi {basic_declarative_item} body

              | 86 =>

            Decrease_Indent;
            End_Declarative_Part;

            -------------------------------------------------------------------
            -- start_bdi ::= empty

        when 87 =>

            Start_Declarative_Part;

            -------------------------------------------------------------------
            -- basic_declarative_item ::= basic_declaration

        when 88

             -------------------------------------------------------------------
             -- basic_declarative_item ::= representation_clause

              | 89

             -------------------------------------------------------------------
             -- basic_declarative_item ::= use_clause

              | 90

             -------------------------------------------------------------------
             -- later_declarative_item ::= subprogram_declaration

              | 92

             -------------------------------------------------------------------
             -- later_declarative_item ::= package_declaration

              | 93

             -------------------------------------------------------------------
             -- later_declarative_item ::= task_specification

              | 94

             -------------------------------------------------------------------
             -- later_declarative_item ::= generic_specification

              | 95

             -------------------------------------------------------------------
             -- later_declarative_item ::= use_clause

              | 96

             -------------------------------------------------------------------
             -- later_declarative_item ::= generic_instantiation

              | 97

             -------------------------------------------------------------------
             -- body ::= proper_body

              | 98

             -------------------------------------------------------------------
             -- body ::= body_stub

              | 99 =>

            New_Line;

            -------------------------------------------------------------------
            -- proper_body ::= subprogram_body

        when 100

             -------------------------------------------------------------------
             -- proper_body ::= package_body

              | 101

             -------------------------------------------------------------------
             -- proper_body ::= task_body

              | 102 =>

            Switch_Comment_Context;

            -------------------------------------------------------------------
            -- binary_adding_operator ::= +

        when 156

             -------------------------------------------------------------------
             -- binary_adding_operator ::= -

              | 157 =>

            Put_Space;

            -------------------------------------------------------------------
            -- sequence_of_statements ::= {pragma_stm} statement {statement}

        when 174 =>

            Decrease_Indent;

            -------------------------------------------------------------------
            -- simple_statement ::= break_decision_point exit_statement

        when 182

             -------------------------------------------------------------------
             -- simple_statement ::= break_always return_statement

              | 183

             -------------------------------------------------------------------
             -- simple_statement ::= break_every_statement goto_statement

              | 184

             -------------------------------------------------------------------
             -- simple_statement ::= break_every_statement abort_statement

              | 186

             -------------------------------------------------------------------
             -- simple_statement ::= break_every_statement raise_statement

              | 187

             -------------------------------------------------------------------
             -- compound_statement ::= break_decision_point if_statement

              | 188

             -------------------------------------------------------------------
             -- compound_statement ::= break_decision_point case_statement

              | 189

             -------------------------------------------------------------------
             -- compound_statement ::= break_decision_point select_statement

              | 191

             -------------------------------------------------------------------
             -- ambiguous_statement ::= break_ambiguous assignment_statement

              | 192

             -------------------------------------------------------------------
             -- ambiguous_statement ::= break_ambiguous code_statement

              | 194

             -------------------------------------------------------------------
             -- ambiguous_statement ::= break_ambiguous loop_statement

              | 195

             -------------------------------------------------------------------
             -- ambiguous_statement ::= break_ambiguous block_statement

              | 196 =>

            New_Line;

            -------------------------------------------------------------------
            -- break_every_statement ::= empty

        when 197 =>

            Add_Breakpoint (Every_Statement);

            -------------------------------------------------------------------
            -- break_decision_point ::= empty

        when 198 =>

            Add_Breakpoint (Decision_Point);

            -------------------------------------------------------------------
            -- break_always ::= empty

        when 199 =>

            Add_Breakpoint (Always);

            -------------------------------------------------------------------
            -- break_ambiguous ::= empty

        when 200 =>

            Add_Breakpoint (Ambiguous);

            -------------------------------------------------------------------
            -- resolve_simple ::= empty

        when 201 =>

            Resolve_Breakpoint (Simple_Statement);

            -------------------------------------------------------------------
            -- null_statement ::= NULL ;

        when 203 =>

            New_Line;

            -------------------------------------------------------------------
            -- sequence_of_statements__end_block_statements ::= sequence_of_statements

        when 217 =>

            End_Block_Sequence_Of_Statements;

            -------------------------------------------------------------------

            -- block_statement ::= [block_identifier:] declare_terminal
            -- declarative_part__begin_end_block [identifier] ;

        when
           218

           -------------------------------------------------------------------

           -- block_statement ::= [block_identifier:] begin_end_block [identifier] ;

            | 219 =>

            End_Block_Statement;

            -------------------------------------------------------------------

            -- subprogram_declaration ::= subprogram_specification ;

        when 227 =>

            Pop_Identifier;

            -------------------------------------------------------------------
            -- subprogram_specification ::= PROCEDURE start_identifier

        when
           228

           -------------------------------------------------------------------
           -- subprogram_specification ::= PROCEDURE start_identifier left_paren

            | 229 =>

            Subprogram_Type ("procedure");

            -------------------------------------------------------------------
            -- subprogram_specification ::= FUNCTION designator RETURN start_expanded_name

        when
           230

           -------------------------------------------------------------------
           -- subprogram_specification ::= FUNCTION designator left_paren right_paren

            | 231 =>

            Subprogram_Type ("function");

            -------------------------------------------------------------------
            -- designator ::= identifier

        when 232

             -------------------------------------------------------------------
             -- designator ::= string_literal

              | 233 =>

            Push_Identifier;

            -------------------------------------------------------------------
            -- parameter_specification ::= identifier_list mode type_mark [:=expression]

        when 234 =>

            Process_Identifier_List (Parameter_List);

            -------------------------------------------------------------------
            -- mode ::= : OUT

        when 236 =>

            Set_Identifier_Mode (Write_Only);

            -------------------------------------------------------------------
            -- generic_parameter_mode ::= :

        when 237 =>

            Insert_In_Token;
            Set_Identifier_Mode (Read_Only);

            -------------------------------------------------------------------
            -- generic_parameter_mode ::= : IN

        when 238 =>

            null;
            Set_Identifier_Mode (Read_Only);

            -------------------------------------------------------------------
            -- generic_parameter_mode ::= : IN OUT

        when 239 =>

            Set_Identifier_Mode (Read_Write);

            -------------------------------------------------------------------
            -- subprogram_body ::= subprogram_specification__IS [end_designator] ;

        when 240 =>

            Decrement_Scope;

            -------------------------------------------------------------------
            -- call_statement ::= name resolve_simple ;

        when 241 =>

            New_Line;

            -------------------------------------------------------------------
            -- package_declaration ::= package_specification ;

        when 242 =>

            Decrement_Scope;

            -------------------------------------------------------------------
            -- package_body ::= PACKAGE__BODY__start_identifier__IS
            --     declarative_part__no_begin

        when
           245

           -------------------------------------------------------------------
           -- package_body ::= PACKAGE__BODY__start_identifier__IS [identifier] ;

            | 246 =>

            Decrement_Scope;

            -------------------------------------------------------------------
            -- declarative_part__no_begin ::= declarative_part

        when 247 =>

            Add_Package_Body_Begin;

            -------------------------------------------------------------------
            -- private_type_declaration ::= TYPE type_identifier IS LIMITED PRIVATE ;

        when 248 =>

            Start_Trace_Procedure (Limited_Private_Type);

            -------------------------------------------------------------------
            -- private_type_declaration ::= TYPE type_identifier left_paren right_paren IS

        when 249 =>

            Start_Trace_Procedure (Limited_Private_Type);

            -------------------------------------------------------------------
            -- private_type_declaration ::= TYPE type_identifier IS PRIVATE ;

        when 250 =>

            Start_Trace_Procedure (Private_Type);

            -------------------------------------------------------------------
            -- private_type_declaration ::= TYPE type_identifier left_paren right_paren IS

        when 251 =>

            Start_Trace_Procedure (Private_Type);

            -------------------------------------------------------------------
            -- package_name ::= start_expanded_name expanded_name

        when 253 =>

            Use_Package_Name;

            -------------------------------------------------------------------
            -- renaming_colon_declaration ::= identifier_list : type_mark RENAMES name ;

        when
           254

           -------------------------------------------------------------------
           -- renaming_colon_declaration ::= identifier_list : EXCEPTION RENAMES ;

            | 255 =>

            Process_Identifier_List (Renaming_List);

            -------------------------------------------------------------------
            -- renaming_declaration ::= PACKAGE start_identifier RENAMES expanded_name ;

        when 256

             -------------------------------------------------------------------
             -- renaming_declaration ::= subprogram_specification RENAMES name ;

              | 257

             -------------------------------------------------------------------
             -- task_specification ::= TASK start_identifier ;

              | 258 =>

            Pop_Identifier;

            -------------------------------------------------------------------
            -- task_specification ::= TASK TYPE start_identifier ;

        when 259 =>

            Pop_Identifier;
            Start_Trace_Procedure (Task_Type);
            End_Type_Declaration;

            -------------------------------------------------------------------
        when 261 =>
            End_Type_Declaration;

            -------------------------------------------------------------------
            -- task_body ::= TASK__BODY__start_identifier__IS [identifier] ;

        when 262 =>

            Decrement_Scope;

            -------------------------------------------------------------------
            -- entry_declaration ::= ENTRY identifier [(discrete_range)][formal_part] ;

        when 263 =>

            New_Line;

            -------------------------------------------------------------------
            -- accept_statement ::= ACCEPT start_identifier [(expression)][formal_part] ;

        when 264 =>

            Pop_Identifier;
            New_Line;

            -------------------------------------------------------------------
            -- accept_statement ::=
            --     ACCEPT__start_identifier__[(expression)][formal_part]__DO

        when 265

             -------------------------------------------------------------------
             -- delay_statement ::= DELAY__start_delay_expression ;

              | 266 =>

            New_Line;

            -------------------------------------------------------------------
            -- DELAY__start_delay_expression ::= DELAY

        when 267 =>

            Start_Delay_Expression;

            -------------------------------------------------------------------
            -- simple_expression__end_delay_expression ::= simple_expression

        when 268 =>

            End_Delay_Expression;

            -------------------------------------------------------------------
            -- select_alternative ::= {pragma_stm}

        when 273

             -------------------------------------------------------------------
             -- select_alternative ::= {pragma_stm} selective_wait_alternative

              | 274 =>

            Decrease_Indent;

            -------------------------------------------------------------------
            -- TERMINATE__; ::= TERMINATE ;

        when 281 =>

            New_Line;

            -------------------------------------------------------------------
            -- accept_statement__decision_point ::= accept_statement

        when 284

             -------------------------------------------------------------------
             -- delay_statement__decision_point ::= delay_statement

              | 285

             -------------------------------------------------------------------
             -- call_statement__decision_point ::= call_statement

              | 286 =>

            Add_Breakpoint (Decision_Point);

            -------------------------------------------------------------------
            -- compilation_unit ::= pragma_header ( general_component_associations ) ;

        when 290

             -------------------------------------------------------------------
             -- compilation_unit ::= pragma_header ;

              | 291 =>

            New_Line;

            -------------------------------------------------------------------
            -- compilation_unit ::= context_clause library_or_secondary_unit

        when 292 =>

            End_Compilation_Unit;

            -------------------------------------------------------------------
            -- library_or_secondary_unit ::= subprogram_body

        when 297

             -------------------------------------------------------------------
             -- library_or_secondary_unit ::= package_body

              | 298 =>

            Switch_Comment_Context;

            -------------------------------------------------------------------
            -- library_unit_name ::= identifier

        when 302 =>

            With_Library_Unit;

            -------------------------------------------------------------------
            -- body_stub ::= subprogram_specification IS SEPARATE ;

        when 303

             -------------------------------------------------------------------
             -- body_stub ::= PACKAGE BODY start_identifier IS SEPARATE ;

              | 304

             -------------------------------------------------------------------
             -- body_stub ::= TASK BODY start_identifier IS SEPARATE ;

              | 305 =>

            Pop_Identifier;

            -------------------------------------------------------------------
            -- exception_declaration ::= identifier_list : EXCEPTION ;

        when 307 =>

            Process_Identifier_List (Exception_List);

            -------------------------------------------------------------------
            -- non_others_handler ::= WHEN__exception_choice__{|exception_choice}__=>

        when
           310

           -------------------------------------------------------------------
           -- others_handler ::= WHEN__exception_OTHERS__=> sequence_of_statements

            | 311 =>

            End_Exception_Sequence_Of_Statements;

            -------------------------------------------------------------------
            -- generic_specification ::= generic_formal_part subprogram_specification ;

        when 315 =>

            Pop_Identifier;

            -------------------------------------------------------------------
            -- generic_specification ::= generic_formal_part package_specification ;

        when 316 =>

            Decrement_Scope;

            -------------------------------------------------------------------
            -- generic_formal_part ::= generic_terminal {generic_parameter_declaration}

        when 317 =>

            Decrease_Indent;

            -------------------------------------------------------------------
            -- generic_parameter_declaration ::= identifier_list generic_parameter_mode ;

        when 318 =>

            New_Line;
            Process_Identifier_List (Generic_Object_List);

            -------------------------------------------------------------------
            -- generic_parameter_declaration ::= TYPE identifier IS generic_type_definition
            --     ;

        when
           319

           -------------------------------------------------------------------
           -- generic_parameter_declaration ::= TYPE identifier left_paren right_paren IS

            | 320 =>

            New_Line;

            -------------------------------------------------------------------
            -- generic_parameter_declaration ::= WITH subprogram_specification ;

        when 321 =>

            New_Line;
            Pop_Identifier;

            -------------------------------------------------------------------
            -- generic_instantiation ::= PACKAGE start_identifier IS__NEW__expanded_name ;

        when
           330

           -------------------------------------------------------------------
           -- generic_instantiation ::= PACKAGE start_identifier IS__NEW__expanded_name (
           --     )

            | 331

           -------------------------------------------------------------------
           -- generic_instantiation ::= FUNCTION designator IS__NEW__expanded_name ;

            | 332

           -------------------------------------------------------------------
           -- generic_instantiation ::= FUNCTION designator IS__NEW__expanded_name ( ) ;

            | 333

           -------------------------------------------------------------------
           -- generic_instantiation ::= subprogram_specification IS__NEW__expanded_name ;

            | 334

           -------------------------------------------------------------------
           -- generic_instantiation ::= subprogram_specification IS__NEW__expanded_name (
           --     )

            | 335 =>

            Decrease_Indent;
            Pop_Identifier;

            -------------------------------------------------------------------
            -- IS__NEW__expanded_name ::= generic_instantiation_IS NEW start_expanded_name

        when 336 =>

            Save_Generic_Name;

            -------------------------------------------------------------------
            -- generic_instantiation_IS ::= IS

        when 337 =>

            New_Line;
            Increase_Indent;

            -------------------------------------------------------------------
            -- representation_clause ::= record_representation_clause

        when 345 =>

            Decrease_Indent;

            -------------------------------------------------------------------
            -- component_clause ::= name AT simple_expression range_constraint ;

        when 350 =>

            New_Line;

            -------------------------------------------------------------------
            -- alignment_clause ::= AT MOD simple_expression ;

        when 351 =>

            New_Line;
            Increase_Indent;

            -------------------------------------------------------------------
            -- [loop_identifier:] ::= empty

        when 440 =>

            Push_Empty_Token;
            Resolve_Breakpoint (Loop_No_Identifier);

            -------------------------------------------------------------------
            -- [loop_identifier:] ::= identifier :

        when 441 =>

            Push_Identifier;
            Resolve_Breakpoint (Loop_With_Identifier);

            -------------------------------------------------------------------
            -- [identifier] ::= empty

        when 442 =>

            Pop_Identifier (To_Output);

            -------------------------------------------------------------------
            -- [identifier] ::= identifier

        when 443 =>

            Pop_Identifier;

            -------------------------------------------------------------------
            -- [block_identifier:] ::= empty

        when 444 =>

            Resolve_Breakpoint (Block_No_Identifier);

            -------------------------------------------------------------------
            -- [block_identifier:] ::= identifier :

        when 445 =>

            Push_Identifier;
            Resolve_Breakpoint (Block_With_Identifier);

            -------------------------------------------------------------------
            -- [exception_handler_part] ::= empty

        when 446 =>

            Add_Exception_Handler;

            -------------------------------------------------------------------
            -- {pragma_alt}__exception_handler ::= {pragma_alt} exception_handler

        when 448 =>

            Decrease_Indent;

            -------------------------------------------------------------------
            -- [others_handler] ::= empty

        when 451 =>

            Add_Others_Handler;

            -------------------------------------------------------------------
            -- [end_designator] ::= empty

        when 455 =>

            Pop_Identifier (To_Output);

            -------------------------------------------------------------------
            -- [end_designator] ::= identifier

        when 456

             -------------------------------------------------------------------
             -- [end_designator] ::= string_literal

              | 457 =>

            Pop_Identifier;

            -------------------------------------------------------------------
            -- {with_clause{use_clause}} ::= {with_clause{use_clause}} with_clause

        when 481 =>

            New_Line;

            -------------------------------------------------------------------
        when 485 =>
            With_Library_Unit;

            -------------------------------------------------------------------
            -- record_terminal ::= RECORD

        when 499 =>

            New_Line;
            Increase_Indent;
            Start_Buffering_Colon_Declarations;
            -- Generate ("start of record type tracevar");

            -------------------------------------------------------------------
            -- closing_{pragma_decl} ::= {pragma_decl}

        when 500

             -------------------------------------------------------------------
             -- {component_declaration}' ::= {component_declaration}

              | 501 =>

            Print_Colon_Declarations_Buffer;

            -------------------------------------------------------------------
            -- start_of_record_type ::= EMPTY

        when 502

             -------------------------------------------------------------------
             -- repspec_record_terminal ::= RECORD

              | 503

             -------------------------------------------------------------------
             -- CASE__identifier__IS ::= CASE__identifier IS

              | 504

             -------------------------------------------------------------------
             -- WHEN__choice__{|choice}__=> ::= WHEN choice {|choice} =>

              | 505

             -------------------------------------------------------------------
             -- WHEN__OTHERS__=> ::= WHEN OTHERS =>

              | 506

             -------------------------------------------------------------------
             -- CASE__expression__IS ::= CASE expression IS

              | 507 =>

            New_Line;
            Increase_Indent;

            -------------------------------------------------------------------
            -- generic_terminal ::= GENERIC

        when 508 =>

            New_Line;
            Increase_Indent;

            -------------------------------------------------------------------
            -- CASE__identifier ::= CASE identifier

        when 509 =>

            null;
            -- Generate ("case var.identifier for record variant");

            -------------------------------------------------------------------
            -- WHEN__variant_choice__{|variant_choice}__=> ::= WHEN__choice__{|choice}__=>

        when 510

             -------------------------------------------------------------------
             -- WHEN__variant_OTHERS__=> ::= WHEN__OTHERS__=>

              | 511 =>

            Start_Buffering_Colon_Declarations;

            -------------------------------------------------------------------
            -- WHEN__case_choice__{|choice}__=> ::= WHEN__choice__{|choice}__=>

        when 512

             -------------------------------------------------------------------
             -- WHEN__case_OTHERS__=> ::= WHEN__OTHERS__=>

              | 513 =>

            Add_Breakpoint (Decision_Point);

            -------------------------------------------------------------------
            -- {pragma_alt}__case_statement_alternative__{case_statement_alternative} ::=

        when 514 =>

            Decrease_Indent;

            -------------------------------------------------------------------
            -- loop_terminal ::= LOOP

        when 515 =>

            New_Line;
            Increase_Indent;
            Start_Loop;

            -------------------------------------------------------------------
            -- begin_terminal ::= BEGIN

        when 516 =>

            Switch_Comment_Context;
            New_Line;
            Increase_Indent;
            Start_Begin_End_Block;

            -------------------------------------------------------------------
            -- {pragma_variant}__variant__{variant} ::= {pragma_variant} variant {variant}

        when 517 =>

            Decrease_Indent;

            -------------------------------------------------------------------
            -- declare_terminal ::= DECLARE

        when 518 =>

            Switch_Comment_Context;
            New_Line;
            Increase_Indent;

            -------------------------------------------------------------------
            -- PACKAGE__start_identifier__IS ::= PACKAGE start_identifier IS

        when 519 =>

            Increment_Scope (Package_Specification);
            New_Line;
            Increase_Indent;

            -------------------------------------------------------------------
            -- start_identifier ::= identifier

        when 520 =>

            Push_Identifier;

            -------------------------------------------------------------------
            -- {basic_declarative_item}' ::= {basic_declarative_item}

        when
           521

           -------------------------------------------------------------------
           -- {entry_declaration}__{representation_clause} ::= {entry_declaration}

            | 522 =>

            Decrease_Indent;

            -------------------------------------------------------------------
            -- private_terminal ::= PRIVATE

        when 523 =>

            New_Line;
            Increase_Indent;
            Start_Private_Part;

            -------------------------------------------------------------------
            -- PACKAGE__BODY__start_identifier__IS ::= PACKAGE BODY start_identifier IS

        when 524 =>

            Increment_Scope (Package_Body);
            New_Line;
            Increase_Indent;

            -------------------------------------------------------------------
            -- TASK__start_identifier__IS ::= TASK start_identifier IS

        when 525 =>

            New_Line;
            Increase_Indent;

            -------------------------------------------------------------------
            -- TASK__TYPE__start_identifier__IS ::= TASK TYPE start_identifier IS

        when 526 =>

            New_Line;
            Increase_Indent;
            Start_Trace_Procedure (Task_Type);

            -------------------------------------------------------------------
            -- TASK__BODY__start_identifier__IS ::= TASK BODY start_identifier IS

        when 527 =>

            Increment_Scope (Task_Body);
            New_Line;
            Increase_Indent;

            -------------------------------------------------------------------
            -- ACCEPT__start_identifier__[(expression)][formal_part]__DO ::= ACCEPT DO

        when 528

             -------------------------------------------------------------------
             -- select_terminal ::= SELECT

              | 529 =>

            New_Line;
            Increase_Indent;

            -------------------------------------------------------------------
            -- call_statement__[sequence_of_statements] ::= call_statement__decision_point

        when 530 =>

            Decrease_Indent;

            -------------------------------------------------------------------
            -- delay_alternative_in_timed_entry ::= delay_alternative

        when
           532

           -------------------------------------------------------------------
           -- WHEN__condition__=>__selective_wait_alternative ::= WHEN__condition__=>

            | 533 =>

            Decrease_Indent;

            -------------------------------------------------------------------
            -- WHEN__condition__=> ::= WHEN condition =>

        when 534

             -------------------------------------------------------------------
             -- exception_terminal ::= EXCEPTION

              | 535 =>

            New_Line;
            Increase_Indent;

            -------------------------------------------------------------------
            -- WHEN__exception_choice__{|exception_choice}__=> ::= WHEN exception_choice =>

        when 536

             -------------------------------------------------------------------
             -- WHEN__exception_OTHERS__=> ::= WHEN OTHERS =>

              | 537 =>

            New_Line;
            Increase_Indent;
            Start_Exception_Branch;

            -------------------------------------------------------------------
            -- subprogram_specification__IS ::= subprogram_specification IS

        when 538 =>

            Increment_Scope (Subprogram_Body);
            New_Line;
            Increase_Indent;

            -------------------------------------------------------------------
            -- {component_clause}' ::= {component_clause}

        when 539 =>

            Decrease_Indent;

            -------------------------------------------------------------------
            -- SEPARATE__(__expanded_name__) ::= SEPARATE__(__expanded_name )

        when 540 =>

            New_Line;

            -------------------------------------------------------------------
            -- SEPARATE__(__expanded_name ::= SEPARATE ( start_expanded_name expanded_name

        when 541 =>

            Save_Separate_Name;

            -------------------------------------------------------------------
            -- start_expanded_name ::= empty

        when 542 =>

            Start_Saving_Expanded_Name;

            -------------------------------------------------------------------
            -- {basic_colon_declaration} ::= start_{basic_colon_declaration} {pragma_decl}

        when 543 =>

            Print_Colon_Declarations_Buffer;

            -------------------------------------------------------------------
            -- start_{basic_colon_declaration} ::= EMPTY

        when 544 =>

            Start_Buffering_Colon_Declarations;

            -------------------------------------------------------------------
            -- condition__THEN ::= condition THEN

        when 549

             -------------------------------------------------------------------
             -- ELSIF__condition__THEN ::= ELSIF condition THEN

              | 550

             -------------------------------------------------------------------
             -- else_terminal ::= ELSE

              | 551 =>

            New_Line;
            Increase_Indent;
            Add_Breakpoint (Decision_Point);

            -------------------------------------------------------------------
            -- or_terminal ::= OR

        when 552 =>

            New_Line;
            Increase_Indent;

            -------------------------------------------------------------------
            -- discriminant__; ::= ;

        when 553

             -------------------------------------------------------------------
             -- parameter__; ::= ;

              | 554 =>

            New_Line;

            -------------------------------------------------------------------
            -- left_paren ::= (

        when 555 =>

            Change_Indent;
            Start_Buffering_Colon_Declarations;

            -------------------------------------------------------------------
            -- right_paren ::= )

        when 556 =>

            Print_Colon_Declarations_Buffer;
            Resume_Normal_Indentation;

        when others =>
            null;
    end case;
end Apply_Actions;