?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE SCL Interpreter : Program Execution Commands' ??
MODULE pmm$program_execution_commands;

{
{ PURPOSE:
{   This module contains the processors for the execute_task, terminate_task,
{   set_program_attributes, and display_program_attributes commands as well
{   as the $program function.

?? NEWTITLE := 'Global Declarations', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc oss$job_paged_literal
*copyc cle$ecc_command_processing
*copyc cle$ecc_expression_result
*copyc cle$ecc_function_processing
*copyc cle$ecc_miscellaneous
*copyc cle$ecc_parameter_list
*copyc pfe$error_condition_codes
*copyc clt$check_parameters_procedure
*copyc clt$parameter_list
*copyc clt$parameter_list_contents
*copyc clt$work_area
*copyc ost$caller_identifier
*copyc ost$status
?? POP ??
*copyc clp$build_path_subtitle
*copyc clp$build_standard_title
*copyc clp$close_display
*copyc clp$convert_integer_to_string
*copyc clp$convert_string_to_file
*copyc clp$count_list_elements
*copyc clp$evaluate_parameters
*copyc clp$execute_named_task
*copyc clp$fetch_named_task_entry
*copyc clp$find_current_block
*copyc clp$find_named_task_group_list
*copyc clp$get_command_search_mode
*copyc clp$get_path_name
*copyc clp$horizontal_tab_display
*copyc clp$make_boolean_value
*copyc clp$make_file_value
*copyc clp$make_sized_string_value
*copyc clp$new_display_line
*copyc clp$open_display_reference
*copyc clp$put_display
*copyc clp$put_partial_display
*copyc clp$reset_for_next_display_page
*copyc clp$set_command_kind
*copyc clp$trimmed_string_size
*copyc clv$nil_display_control
*copyc clv$standard_files
*copyc osp$append_status_parameter
*copyc osp$disestablish_cond_handler
*copyc osp$establish_block_exit_hndlr
*copyc osp$set_status_abnormal
*copyc osv$lower_to_upper
*copyc pmp$change_default_prog_options
*copyc pmp$change_job_library_list
*copyc pmp$execute
*copyc pmp$find_prog_options_and_libs
*copyc pmp$get_task_id
*copyc pmp$job_debug_ring
*copyc pmp$terminate
*copyc pmv$preset_conversion_table

  CONST
    max_term_error_level_str_size = 7, {warning
    max_preset_string_size = 25; {floating_point_indefinite

  VAR
    termination_error_level_string: [STATIC, READ, oss$job_paged_literal] array
          [pmc$warning_load_errors .. pmc$fatal_load_errors] of string (max_term_error_level_str_size) :=
          ['warning', 'error', 'fatal'],
    preset_string: [STATIC, READ, oss$job_paged_literal] array [pmt$initialization_value] of
          string (max_preset_string_size) := ['zero', 'alternate_ones', 'floating_point_indefinite',
          'infinity'];

?? TITLE := '[XDCL] pmp$_set_program_attributes', EJECT ??

{ PURPOSE:
{  This routine processes the set_program_attribute command.
{

  PROCEDURE [XDCL] pmp$_set_program_attributes
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE (osm$setpa) set_program_attributes, set_program_attribute, setpa (
{   load_map, lm: file = $optional
{   load_map_options, load_map_option, lmo: any of
{       key all, none keyend
{       list of key
{         (segment, s)
{         (block, b)
{         (entry_point, ep)
{         (cross_reference, cr)
{       keyend
{     anyend = $optional
{   preset_value, pv: key
{       (zero, z)
{       (floating_point_indefinite, fpi)
{       (infinity, i)
{       (alternate_ones, ao)
{     keyend = $optional
{   termination_error_level, tel: key
{       (warning, w)
{       (error, e)
{       (fatal, f)
{     keyend = $optional
{   debug_input, di: file = $optional
{   debug_output, do: file = $optional
{   abort_file, af: file = $optional
{   debug_mode, dm: boolean = $optional
{   delete_libraries, delete_library, dl: any of
{       key all keyend
{       list of any of
{         key osf$task_services_library keyend
{         file
{       anyend
{     anyend = $optional
{   add_libraries, add_library, al: list of any of
{       key
{         osf$task_services_library
{       keyend
{       file
{     anyend = $optional
{   arithmetic_overflow, ao: boolean = $optional
{   arithmetic_loss_of_significance, alos: boolean = $optional
{   divide_fault, df: boolean = $optional
{   exponent_overflow, eo: boolean = $optional
{   exponent_underflow, eu: boolean = $optional
{   fp_indefinite, fpi, fi: boolean = $optional
{   fp_loss_of_significance, fplos, flos: boolean = $optional
{   invalid_bdp_data, ibdpd, ibd: boolean = $optional
{   status)

?? PUSH (LISTEXT := ON) ??

    VAR
      pdt: [STATIC, READ, cls$declaration_section] record
        header: clt$pdt_header,
        names: array [1 .. 43] of clt$pdt_parameter_name,
        parameters: array [1 .. 19] of clt$pdt_parameter,
        type1: record
          header: clt$type_specification_header,
        recend,
        type2: record
          header: clt$type_specification_header,
          qualifier: clt$union_type_qualifier,
          type_size_1: clt$type_specification_size,
          element_type_spec_1: record
            header: clt$type_specification_header,
            qualifier: clt$keyword_type_qualifier,
            keyword_specs: array [1 .. 2] of clt$keyword_specification,
          recend,
          type_size_2: clt$type_specification_size,
          element_type_spec_2: record
            header: clt$type_specification_header,
            qualifier: clt$list_type_qualifier,
            element_type_spec: record
              header: clt$type_specification_header,
              qualifier: clt$keyword_type_qualifier,
              keyword_specs: array [1 .. 8] of clt$keyword_specification,
            recend,
          recend,
        recend,
        type3: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 8] of clt$keyword_specification,
        recend,
        type4: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 6] of clt$keyword_specification,
        recend,
        type5: record
          header: clt$type_specification_header,
        recend,
        type6: record
          header: clt$type_specification_header,
        recend,
        type7: record
          header: clt$type_specification_header,
        recend,
        type8: record
          header: clt$type_specification_header,
        recend,
        type9: record
          header: clt$type_specification_header,
          qualifier: clt$union_type_qualifier,
          type_size_1: clt$type_specification_size,
          element_type_spec_1: record
            header: clt$type_specification_header,
            qualifier: clt$keyword_type_qualifier,
            keyword_specs: array [1 .. 1] of clt$keyword_specification,
          recend,
          type_size_2: clt$type_specification_size,
          element_type_spec_2: record
            header: clt$type_specification_header,
            qualifier: clt$list_type_qualifier,
            element_type_spec: record
              header: clt$type_specification_header,
              qualifier: clt$union_type_qualifier,
              type_size_1: clt$type_specification_size,
              element_type_spec_1: record
                header: clt$type_specification_header,
                qualifier: clt$keyword_type_qualifier,
                keyword_specs: array [1 .. 1] of clt$keyword_specification,
              recend,
              type_size_2: clt$type_specification_size,
              element_type_spec_2: record
                header: clt$type_specification_header,
              recend,
            recend,
          recend,
        recend,
        type10: record
          header: clt$type_specification_header,
          qualifier: clt$list_type_qualifier,
          element_type_spec: record
            header: clt$type_specification_header,
            qualifier: clt$union_type_qualifier,
            type_size_1: clt$type_specification_size,
            element_type_spec_1: record
              header: clt$type_specification_header,
              qualifier: clt$keyword_type_qualifier,
              keyword_specs: array [1 .. 1] of clt$keyword_specification,
            recend,
            type_size_2: clt$type_specification_size,
            element_type_spec_2: record
              header: clt$type_specification_header,
            recend,
          recend,
        recend,
        type11: record
          header: clt$type_specification_header,
        recend,
        type12: record
          header: clt$type_specification_header,
        recend,
        type13: record
          header: clt$type_specification_header,
        recend,
        type14: record
          header: clt$type_specification_header,
        recend,
        type15: record
          header: clt$type_specification_header,
        recend,
        type16: record
          header: clt$type_specification_header,
        recend,
        type17: record
          header: clt$type_specification_header,
        recend,
        type18: record
          header: clt$type_specification_header,
        recend,
        type19: record
          header: clt$type_specification_header,
        recend,
      recend := [[1, [88, 9, 26, 14, 34, 40, 117], clc$command, 43, 19, 0, 0, 0, 0, 19, 'OSM$SETPA'],
            [['ABORT_FILE                     ', clc$nominal_entry, 7],
            ['ADD_LIBRARIES                  ', clc$nominal_entry, 10],
            ['ADD_LIBRARY                    ', clc$alias_entry, 10],
            ['AF                             ', clc$abbreviation_entry, 7],
            ['AL                             ', clc$abbreviation_entry, 10],
            ['ALOS                           ', clc$abbreviation_entry, 12],
            ['AO                             ', clc$abbreviation_entry, 11],
            ['ARITHMETIC_LOSS_OF_SIGNIFICANCE', clc$nominal_entry, 12],
            ['ARITHMETIC_OVERFLOW            ', clc$nominal_entry, 11],
            ['DEBUG_INPUT                    ', clc$nominal_entry, 5],
            ['DEBUG_MODE                     ', clc$nominal_entry, 8],
            ['DEBUG_OUTPUT                   ', clc$nominal_entry, 6],
            ['DELETE_LIBRARIES               ', clc$nominal_entry, 9],
            ['DELETE_LIBRARY                 ', clc$alias_entry, 9],
            ['DF                             ', clc$abbreviation_entry, 13],
            ['DI                             ', clc$abbreviation_entry, 5],
            ['DIVIDE_FAULT                   ', clc$nominal_entry, 13],
            ['DL                             ', clc$abbreviation_entry, 9],
            ['DM                             ', clc$abbreviation_entry, 8],
            ['DO                             ', clc$abbreviation_entry, 6],
            ['EO                             ', clc$abbreviation_entry, 14],
            ['EU                             ', clc$abbreviation_entry, 15],
            ['EXPONENT_OVERFLOW              ', clc$nominal_entry, 14],
            ['EXPONENT_UNDERFLOW             ', clc$nominal_entry, 15],
            ['FI                             ', clc$abbreviation_entry, 16],
            ['FLOS                           ', clc$abbreviation_entry, 17],
            ['FPI                            ', clc$alias_entry, 16],
            ['FPLOS                          ', clc$alias_entry, 17],
            ['FP_INDEFINITE                  ', clc$nominal_entry, 16],
            ['FP_LOSS_OF_SIGNIFICANCE        ', clc$nominal_entry, 17],
            ['IBD                            ', clc$abbreviation_entry, 18],
            ['IBDPD                          ', clc$alias_entry, 18],
            ['INVALID_BDP_DATA               ', clc$nominal_entry, 18],
            ['LM                             ', clc$abbreviation_entry, 1],
            ['LMO                            ', clc$abbreviation_entry, 2],
            ['LOAD_MAP                       ', clc$nominal_entry, 1],
            ['LOAD_MAP_OPTION                ', clc$alias_entry, 2],
            ['LOAD_MAP_OPTIONS               ', clc$nominal_entry, 2],
            ['PRESET_VALUE                   ', clc$nominal_entry, 3],
            ['PV                             ', clc$abbreviation_entry, 3],
            ['STATUS                         ', clc$nominal_entry, 19],
            ['TEL                            ', clc$abbreviation_entry, 4],
            ['TERMINATION_ERROR_LEVEL        ', clc$nominal_entry, 4]], [

{ PARAMETER 1

      [36, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0],

{ PARAMETER 2

      [38, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 420, clc$optional_parameter, 0, 0],

{ PARAMETER 3

      [39, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 303, clc$optional_parameter, 0, 0],

{ PARAMETER 4

      [43, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 229, clc$optional_parameter, 0, 0],

{ PARAMETER 5

      [10, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0],

{ PARAMETER 6

      [12, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0],

{ PARAMETER 7

      [1, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0],

{ PARAMETER 8

      [11, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0],

{ PARAMETER 9

      [13, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 147, clc$optional_parameter, 0, 0],

{ PARAMETER 10

      [2, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 83, clc$optional_parameter, 0, 0],

{ PARAMETER 11

      [9, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0],

{ PARAMETER 12

      [8, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0],

{ PARAMETER 13

      [17, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0],

{ PARAMETER 14

      [23, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0],

{ PARAMETER 15

      [24, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0],

{ PARAMETER 16

      [29, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0],

{ PARAMETER 17

      [30, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0],

{ PARAMETER 18

      [33, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0],

{ PARAMETER 19

      [41, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name], clc$pass_by_reference, clc$immediate_evaluation,
            clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0]],

{ PARAMETER 1

      [[1, 0, clc$file_type]],

{ PARAMETER 2

      [[1, 0, clc$union_type], [[clc$keyword_type, clc$list_type], FALSE, 2], 81,
            [[1, 0, clc$keyword_type], [2], [['ALL                            ', clc$nominal_entry,
            clc$normal_usage_entry, 1], ['NONE                           ', clc$nominal_entry,
            clc$normal_usage_entry, 2]]], 319, [[1, 0, clc$list_type],
            [303, 1, clc$max_list_size, FALSE], [[1, 0, clc$keyword_type],
            [8], [['B                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
            ['BLOCK                          ', clc$nominal_entry, clc$normal_usage_entry, 2],
            ['CR                             ', clc$abbreviation_entry, clc$normal_usage_entry, 4],
            ['CROSS_REFERENCE                ', clc$nominal_entry, clc$normal_usage_entry, 4],
            ['ENTRY_POINT                    ', clc$nominal_entry, clc$normal_usage_entry, 3],
            ['EP                             ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
            ['S                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
            ['SEGMENT                        ', clc$nominal_entry, clc$normal_usage_entry, 1]]]]],

{ PARAMETER 3

      [[1, 0, clc$keyword_type], [8], [['ALTERNATE_ONES                 ', clc$nominal_entry,
            clc$normal_usage_entry, 4], ['AO                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 4], ['FLOATING_POINT_INDEFINITE      ', clc$nominal_entry,
            clc$normal_usage_entry, 2], ['FPI                            ', clc$abbreviation_entry,
            clc$normal_usage_entry, 2], ['I                              ', clc$abbreviation_entry,
            clc$normal_usage_entry, 3], ['INFINITY                       ', clc$nominal_entry,
            clc$normal_usage_entry, 3], ['Z                              ', clc$abbreviation_entry,
            clc$normal_usage_entry, 1], ['ZERO                           ', clc$nominal_entry,
            clc$normal_usage_entry, 1]]],

{ PARAMETER 4

      [[1, 0, clc$keyword_type], [6], [['E                              ', clc$abbreviation_entry,
            clc$normal_usage_entry, 2], ['ERROR                          ', clc$nominal_entry,
            clc$normal_usage_entry, 2], ['F                              ', clc$abbreviation_entry,
            clc$normal_usage_entry, 3], ['FATAL                          ', clc$nominal_entry,
            clc$normal_usage_entry, 3], ['W                              ', clc$abbreviation_entry,
            clc$normal_usage_entry, 1], ['WARNING                        ', clc$nominal_entry,
            clc$normal_usage_entry, 1]]],

{ PARAMETER 5

      [[1, 0, clc$file_type]],

{ PARAMETER 6

      [[1, 0, clc$file_type]],

{ PARAMETER 7

      [[1, 0, clc$file_type]],

{ PARAMETER 8

      [[1, 0, clc$boolean_type]],

{ PARAMETER 9

      [[1, 0, clc$union_type], [[clc$keyword_type, clc$list_type], FALSE, 2], 44,
            [[1, 0, clc$keyword_type], [1], [['ALL                            ', clc$nominal_entry,
            clc$normal_usage_entry, 1]]], 83, [[1, 0, clc$list_type],
            [67, 1, clc$max_list_size, FALSE], [[1, 0, clc$union_type],
            [[clc$file_type, clc$keyword_type], FALSE, 2], 44,
            [[1, 0, clc$keyword_type], [1], [['OSF$TASK_SERVICES_LIBRARY      ', clc$nominal_entry,
            clc$normal_usage_entry, 1]]], 3, [[1, 0, clc$file_type]]]]],

{ PARAMETER 10

      [[1, 0, clc$list_type], [67, 1, clc$max_list_size, FALSE],
            [[1, 0, clc$union_type], [[clc$file_type, clc$keyword_type], FALSE, 2], 44,
            [[1, 0, clc$keyword_type], [1], [['OSF$TASK_SERVICES_LIBRARY      ', clc$nominal_entry,
            clc$normal_usage_entry, 1]]], 3, [[1, 0, clc$file_type]]]],

{ PARAMETER 11

      [[1, 0, clc$boolean_type]],

{ PARAMETER 12

      [[1, 0, clc$boolean_type]],

{ PARAMETER 13

      [[1, 0, clc$boolean_type]],

{ PARAMETER 14

      [[1, 0, clc$boolean_type]],

{ PARAMETER 15

      [[1, 0, clc$boolean_type]],

{ PARAMETER 16

      [[1, 0, clc$boolean_type]],

{ PARAMETER 17

      [[1, 0, clc$boolean_type]],

{ PARAMETER 18

      [[1, 0, clc$boolean_type]],

{ PARAMETER 19

      [[1, 0, clc$status_type]]];

?? POP ??

    CONST
      p$load_map = 1,
      p$load_map_options = 2,
      p$preset_value = 3,
      p$termination_error_level = 4,
      p$debug_input = 5,
      p$debug_output = 6,
      p$abort_file = 7,
      p$debug_mode = 8,
      p$delete_libraries = 9,
      p$add_libraries = 10,
      p$arithmetic_overflow = 11,
      p$arithmetic_loss_of_significan = 12 {ARITHMETIC_LOSS_OF_SIGNIFICANCE} ,
      p$divide_fault = 13,
      p$exponent_overflow = 14,
      p$exponent_underflow = 15,
      p$fp_indefinite = 16,
      p$fp_loss_of_significance = 17,
      p$invalid_bdp_data = 18,
      p$status = 19;

    VAR
      pvt: array [1 .. 19] of clt$parameter_value;

?? NEWTITLE := 'check_parameters', EJECT ??

    PROCEDURE check_parameters
      (    parameter_value_table: ^clt$parameter_value_table;
           which_parameter: clt$which_parameter;
       VAR status: ost$status);

      IF NOT (parameter_value_table^ [p$load_map].specified OR
            parameter_value_table^ [p$load_map_options].specified OR
            parameter_value_table^ [p$preset_value].specified OR
            parameter_value_table^ [p$termination_error_level].
            specified OR parameter_value_table^ [p$debug_input].
            specified OR parameter_value_table^ [p$debug_output].
            specified OR parameter_value_table^ [p$abort_file].
            specified OR parameter_value_table^ [p$debug_mode].
            specified OR parameter_value_table^ [p$arithmetic_overflow].
            specified OR parameter_value_table^ [p$arithmetic_loss_of_significan].specified OR
            parameter_value_table^ [p$divide_fault].specified OR
            parameter_value_table^ [p$exponent_overflow].specified OR
            parameter_value_table^ [p$exponent_underflow].specified OR
            parameter_value_table^ [p$fp_indefinite].specified OR
            parameter_value_table^ [p$fp_loss_of_significance].
            specified OR parameter_value_table^ [p$invalid_bdp_data].
            specified OR parameter_value_table^ [p$add_libraries].
            specified OR parameter_value_table^ [p$delete_libraries].specified) THEN
        osp$set_status_abnormal ('CL', cle$required_parameter_omitted, 'LOAD_MAP .. INVALID_BDP_DATA',
              status);
        RETURN;
      IFEND;

    PROCEND check_parameters;
?? OLDTITLE, EJECT ??

    VAR
      add_count: clt$list_size,
      add_libraries: ^pmt$object_library_list,
      changed_conditions: boolean,
      delete_count: clt$list_size,
      delete_libraries: ^pmt$object_library_list,
      element: ^clt$data_value,
      file: clt$file,
      library_index: clt$list_size,
      option_change: pmt$default_prog_options_change,
      option_count: clt$list_size,
      option_index: clt$list_size,
      value: ^clt$data_value;

    clp$evaluate_parameters (parameter_list, #SEQ (pdt), ^check_parameters, ^pvt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    option_change.contents := $pmt$program_option_specifiers [];

    IF pvt [p$load_map].specified THEN
      option_change.contents := option_change.contents + $pmt$program_option_specifiers
            [pmc$load_map_file_specified];
      clp$convert_string_to_file (pvt [p$load_map].value^.file_value^, file, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      option_change.map_file := file.local_file_name;
    IFEND;

    IF pvt [p$load_map_options].specified THEN
      option_change.contents := option_change.contents + $pmt$program_option_specifiers
            [pmc$load_map_options_specified];
      get_load_map_options (pvt [p$load_map_options], option_change.map_options, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
    IFEND;

    IF pvt [p$preset_value].specified THEN
      option_change.contents := option_change.contents + $pmt$program_option_specifiers
            [pmc$preset_specified];
      value := pvt [p$preset_value].value;
      IF value^.keyword_value = 'FLOATING_POINT_INDEFINITE' THEN
        option_change.preset := pmc$initialize_to_indefinite;
      ELSEIF value^.keyword_value = 'INFINITY' THEN
        option_change.preset := pmc$initialize_to_infinity;
      ELSEIF value^.keyword_value = 'ALTERNATE_ONES' THEN
        option_change.preset := pmc$initialize_to_alt_ones;
      ELSEIF value^.keyword_value = 'ZERO' THEN
        option_change.preset := pmc$initialize_to_zero;
      IFEND;
    IFEND;

    IF pvt [p$termination_error_level].specified THEN
      option_change.contents := option_change.contents + $pmt$program_option_specifiers
            [pmc$term_error_level_specified];
      value := pvt [p$termination_error_level].value;
      IF value^.keyword_value = 'WARNING' THEN
        option_change.termination_error_level := pmc$warning_load_errors;
      ELSEIF value^.keyword_value = 'ERROR' THEN
        option_change.termination_error_level := pmc$error_load_errors;
      ELSEIF value^.keyword_value = 'FATAL' THEN
        option_change.termination_error_level := pmc$fatal_load_errors;
      IFEND;
    IFEND;

    IF pvt [p$debug_input].specified THEN
      option_change.contents := option_change.contents + $pmt$program_option_specifiers
            [pmc$debug_input_specified];
      clp$convert_string_to_file (pvt [p$debug_input].value^.file_value^, file, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      option_change.debug_input := file.local_file_name;
    IFEND;

    IF pvt [p$debug_output].specified THEN
      option_change.contents := option_change.contents + $pmt$program_option_specifiers
            [pmc$debug_output_specified];
      clp$convert_string_to_file (pvt [p$debug_output].value^.file_value^, file, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      option_change.debug_output := file.local_file_name;
    IFEND;

    IF pvt [p$abort_file].specified THEN
      option_change.contents := option_change.contents + $pmt$program_option_specifiers
            [pmc$abort_file_specified];
      clp$convert_string_to_file (pvt [p$abort_file].value^.file_value^, file, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      option_change.abort_file := file.local_file_name;
    IFEND;

    IF pvt [p$debug_mode].specified THEN
      option_change.contents := option_change.contents + $pmt$program_option_specifiers
            [pmc$debug_mode_specified];
      option_change.debug_mode := pvt [p$debug_mode].value^.boolean_value.value;
    IFEND;

    changed_conditions := FALSE;
    option_change.conditions_enabled := $pmt$system_conditions [];
    option_change.conditions_inhibited := $pmt$system_conditions [];
    IF pvt [p$arithmetic_overflow].specified THEN
      changed_conditions := TRUE;
      IF pvt [p$arithmetic_overflow].value^.boolean_value.value THEN
        option_change.conditions_enabled := option_change.conditions_enabled +
              $pmt$system_conditions [pmc$arithmetic_overflow];
      ELSE
        option_change.conditions_inhibited := option_change.conditions_inhibited +
              $pmt$system_conditions [pmc$arithmetic_overflow];
      IFEND;
    IFEND;

    IF pvt [p$arithmetic_loss_of_significan].specified THEN
      changed_conditions := TRUE;
      IF pvt [p$arithmetic_loss_of_significan].value^.boolean_value.value THEN
        option_change.conditions_enabled := option_change.conditions_enabled +
              $pmt$system_conditions [pmc$arithmetic_significance];
      ELSE
        option_change.conditions_inhibited := option_change.conditions_inhibited +
              $pmt$system_conditions [pmc$arithmetic_significance];
      IFEND;
    IFEND;

    IF pvt [p$divide_fault].specified THEN
      changed_conditions := TRUE;
      IF pvt [p$divide_fault].value^.boolean_value.value THEN
        option_change.conditions_enabled := option_change.conditions_enabled +
              $pmt$system_conditions [pmc$divide_fault];
      ELSE
        option_change.conditions_inhibited := option_change.conditions_inhibited +
              $pmt$system_conditions [pmc$divide_fault];
      IFEND;
    IFEND;

    IF pvt [p$exponent_overflow].specified THEN
      changed_conditions := TRUE;
      IF pvt [p$exponent_overflow].value^.boolean_value.value THEN
        option_change.conditions_enabled := option_change.conditions_enabled +
              $pmt$system_conditions [pmc$exponent_overflow];
      ELSE
        option_change.conditions_inhibited := option_change.conditions_inhibited +
              $pmt$system_conditions [pmc$exponent_overflow];
      IFEND;
    IFEND;

    IF pvt [p$exponent_underflow].specified THEN
      changed_conditions := TRUE;
      IF pvt [p$exponent_underflow].value^.boolean_value.value THEN
        option_change.conditions_enabled := option_change.conditions_enabled +
              $pmt$system_conditions [pmc$exponent_underflow];
      ELSE
        option_change.conditions_inhibited := option_change.conditions_inhibited +
              $pmt$system_conditions [pmc$exponent_underflow];
      IFEND;
    IFEND;

    IF pvt [p$fp_indefinite].specified THEN
      changed_conditions := TRUE;
      IF pvt [p$fp_indefinite].value^.boolean_value.value THEN
        option_change.conditions_enabled := option_change.conditions_enabled +
              $pmt$system_conditions [pmc$fp_indefinite];
      ELSE
        option_change.conditions_inhibited := option_change.conditions_inhibited +
              $pmt$system_conditions [pmc$fp_indefinite];
      IFEND;
    IFEND;

    IF pvt [p$fp_loss_of_significance].specified THEN
      changed_conditions := TRUE;
      IF pvt [p$fp_loss_of_significance].value^.boolean_value.value THEN
        option_change.conditions_enabled := option_change.conditions_enabled +
              $pmt$system_conditions [pmc$fp_significance_loss];
      ELSE
        option_change.conditions_inhibited := option_change.conditions_inhibited +
              $pmt$system_conditions [pmc$fp_significance_loss];
      IFEND;
    IFEND;

    IF pvt [p$invalid_bdp_data].specified THEN
      changed_conditions := TRUE;
      IF pvt [p$invalid_bdp_data].value^.boolean_value.value THEN
        option_change.conditions_enabled := option_change.conditions_enabled +
              $pmt$system_conditions [pmc$invalid_bdp_data];
      ELSE
        option_change.conditions_inhibited := option_change.conditions_inhibited +
              $pmt$system_conditions [pmc$invalid_bdp_data];
      IFEND;
    IFEND;

    IF changed_conditions THEN
      option_change.contents := option_change.contents + $pmt$program_option_specifiers
            [pmc$condition_specified];
    IFEND;

    IF option_change.contents <> $pmt$program_option_specifiers [] THEN
      pmp$change_default_prog_options (option_change, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
    IFEND;

    value := pvt [p$delete_libraries].value;
    IF NOT pvt [p$delete_libraries].specified THEN
      delete_libraries := NIL;
    ELSEIF value^.kind = clc$keyword { ALL} THEN
      PUSH delete_libraries: [1 .. 1];
      delete_libraries^ [1] := value^.keyword_value;
    ELSE
      delete_count := clp$count_list_elements (value);
      PUSH delete_libraries: [1 .. delete_count];
      FOR library_index := 1 TO delete_count DO
        element := value^.element_value;
        IF element^.kind = clc$keyword THEN
          delete_libraries^ [library_index] := element^.keyword_value;
        ELSE
          clp$convert_string_to_file (element^.file_value^, file, status);
          IF NOT status.normal THEN
            RETURN;
          IFEND;
          delete_libraries^ [library_index] := file.local_file_name;
        IFEND;
        value := value^.link;
      FOREND;
    IFEND;

    IF pvt [p$add_libraries].specified THEN
      value := pvt [p$add_libraries].value;
      add_count := clp$count_list_elements (value);
      PUSH add_libraries: [1 .. add_count];
      FOR library_index := 1 TO add_count DO
        element := value^.element_value;
        IF element^.kind = clc$keyword { ALL} THEN
          add_libraries^ [library_index] := element^.keyword_value;
        ELSE
          clp$convert_string_to_file (element^.file_value^, file, status);
          IF NOT status.normal THEN
            RETURN;
          IFEND;
          add_libraries^ [library_index] := file.local_file_name;
        IFEND;
        value := value^.link;
      FOREND;
    ELSE
      add_libraries := NIL;
    IFEND;

    pmp$change_job_library_list (delete_libraries, add_libraries, status);

  PROCEND pmp$_set_program_attributes;
?? TITLE := '[XDCL] pmp$_execute_task', EJECT ??

{ PURPOSE:
{  This is the command processor for the execute_task command.
{

  PROCEDURE [XDCL] pmp$_execute_task
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE (osm$exet) execute_task, exet (
{   files, file, f: list of file = $optional
{   parameters, parameter, p: string = $optional
{   libraries, library, l: list of any of
{       key
{         osf$task_services_library
{       keyend
{       file
{     anyend = $optional
{   modules, module, m: list of program_name = $optional
{   starting_procedure, sp: program_name = $optional
{   load_map, lm: file = $optional
{   load_map_options, load_map_option, lmo: any of
{       key all, none keyend
{       list of key
{         (segment, s)
{         (block, b)
{         (entry_point, ep)
{         (cross_reference, cr)
{       keyend
{     anyend = $optional
{   preset_value, pv: key
{       (zero, z)
{       (floating_point_indefinite, fpi)
{       (infinity, i)
{       (alternate_ones, ao)
{     keyend = $optional
{   termination_error_level, tel: key
{       (warning, w)
{       (error, e)
{       (fatal, f)
{     keyend = $optional
{   stack_size, ss: integer 1..osc$max_segment_length = $optional
{   debug_input, di: file = $optional
{   debug_output, do: file = $optional
{   abort_file, af: file = $optional
{   debug_mode, dm: boolean = $optional
{   task_name, tn: name = $optional
{   arithmetic_overflow, ao: boolean = $optional
{   arithmetic_loss_of_significance, alos: boolean = $optional
{   divide_fault, df: boolean = $optional
{   exponent_overflow, eo: boolean = $optional
{   exponent_underflow, eu: boolean = $optional
{   fp_indefinite, fpi, fi: boolean = $optional
{   fp_loss_of_significance, fplos, flos: boolean = $optional
{   invalid_bdp_data, ibdpd, ibd: boolean = $optional
{   status)

?? PUSH (LISTEXT := ON) ??

    VAR
      pdt: [STATIC, READ, cls$declaration_section] record
        header: clt$pdt_header,
        names: array [1 .. 55] of clt$pdt_parameter_name,
        parameters: array [1 .. 24] of clt$pdt_parameter,
        type1: record
          header: clt$type_specification_header,
          qualifier: clt$list_type_qualifier,
          element_type_spec: record
            header: clt$type_specification_header,
          recend,
        recend,
        type2: record
          header: clt$type_specification_header,
          qualifier: clt$string_type_qualifier,
        recend,
        type3: record
          header: clt$type_specification_header,
          qualifier: clt$list_type_qualifier,
          element_type_spec: record
            header: clt$type_specification_header,
            qualifier: clt$union_type_qualifier,
            type_size_1: clt$type_specification_size,
            element_type_spec_1: record
              header: clt$type_specification_header,
              qualifier: clt$keyword_type_qualifier,
              keyword_specs: array [1 .. 1] of clt$keyword_specification,
            recend,
            type_size_2: clt$type_specification_size,
            element_type_spec_2: record
              header: clt$type_specification_header,
            recend,
          recend,
        recend,
        type4: record
          header: clt$type_specification_header,
          qualifier: clt$list_type_qualifier,
          element_type_spec: record
            header: clt$type_specification_header,
          recend,
        recend,
        type5: record
          header: clt$type_specification_header,
        recend,
        type6: record
          header: clt$type_specification_header,
        recend,
        type7: record
          header: clt$type_specification_header,
          qualifier: clt$union_type_qualifier,
          type_size_1: clt$type_specification_size,
          element_type_spec_1: record
            header: clt$type_specification_header,
            qualifier: clt$keyword_type_qualifier,
            keyword_specs: array [1 .. 2] of clt$keyword_specification,
          recend,
          type_size_2: clt$type_specification_size,
          element_type_spec_2: record
            header: clt$type_specification_header,
            qualifier: clt$list_type_qualifier,
            element_type_spec: record
              header: clt$type_specification_header,
              qualifier: clt$keyword_type_qualifier,
              keyword_specs: array [1 .. 8] of clt$keyword_specification,
            recend,
          recend,
        recend,
        type8: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 8] of clt$keyword_specification,
        recend,
        type9: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 6] of clt$keyword_specification,
        recend,
        type10: record
          header: clt$type_specification_header,
          qualifier: clt$integer_type_qualifier,
        recend,
        type11: record
          header: clt$type_specification_header,
        recend,
        type12: record
          header: clt$type_specification_header,
        recend,
        type13: record
          header: clt$type_specification_header,
        recend,
        type14: record
          header: clt$type_specification_header,
        recend,
        type15: record
          header: clt$type_specification_header,
          qualifier: clt$name_type_qualifier,
        recend,
        type16: record
          header: clt$type_specification_header,
        recend,
        type17: record
          header: clt$type_specification_header,
        recend,
        type18: record
          header: clt$type_specification_header,
        recend,
        type19: record
          header: clt$type_specification_header,
        recend,
        type20: record
          header: clt$type_specification_header,
        recend,
        type21: record
          header: clt$type_specification_header,
        recend,
        type22: record
          header: clt$type_specification_header,
        recend,
        type23: record
          header: clt$type_specification_header,
        recend,
        type24: record
          header: clt$type_specification_header,
        recend,
      recend := [[1, [88, 9, 26, 14, 35, 15, 211], clc$command, 55, 24, 0, 0, 0, 0, 24, 'OSM$EXET'],
            [['ABORT_FILE                     ', clc$nominal_entry, 13],
            ['AF                             ', clc$abbreviation_entry, 13],
            ['ALOS                           ', clc$abbreviation_entry, 17],
            ['AO                             ', clc$abbreviation_entry, 16],
            ['ARITHMETIC_LOSS_OF_SIGNIFICANCE', clc$nominal_entry, 17],
            ['ARITHMETIC_OVERFLOW            ', clc$nominal_entry, 16],
            ['DEBUG_INPUT                    ', clc$nominal_entry, 11],
            ['DEBUG_MODE                     ', clc$nominal_entry, 14],
            ['DEBUG_OUTPUT                   ', clc$nominal_entry, 12],
            ['DF                             ', clc$abbreviation_entry, 18],
            ['DI                             ', clc$abbreviation_entry, 11],
            ['DIVIDE_FAULT                   ', clc$nominal_entry, 18],
            ['DM                             ', clc$abbreviation_entry, 14],
            ['DO                             ', clc$abbreviation_entry, 12],
            ['EO                             ', clc$abbreviation_entry, 19],
            ['EU                             ', clc$abbreviation_entry, 20],
            ['EXPONENT_OVERFLOW              ', clc$nominal_entry, 19],
            ['EXPONENT_UNDERFLOW             ', clc$nominal_entry, 20],
            ['F                              ', clc$abbreviation_entry, 1],
            ['FI                             ', clc$abbreviation_entry, 21],
            ['FILE                           ', clc$alias_entry, 1],
            ['FILES                          ', clc$nominal_entry, 1],
            ['FLOS                           ', clc$abbreviation_entry, 22],
            ['FPI                            ', clc$alias_entry, 21],
            ['FPLOS                          ', clc$alias_entry, 22],
            ['FP_INDEFINITE                  ', clc$nominal_entry, 21],
            ['FP_LOSS_OF_SIGNIFICANCE        ', clc$nominal_entry, 22],
            ['IBD                            ', clc$abbreviation_entry, 23],
            ['IBDPD                          ', clc$alias_entry, 23],
            ['INVALID_BDP_DATA               ', clc$nominal_entry, 23],
            ['L                              ', clc$abbreviation_entry, 3],
            ['LIBRARIES                      ', clc$nominal_entry, 3],
            ['LIBRARY                        ', clc$alias_entry, 3],
            ['LM                             ', clc$abbreviation_entry, 6],
            ['LMO                            ', clc$abbreviation_entry, 7],
            ['LOAD_MAP                       ', clc$nominal_entry, 6],
            ['LOAD_MAP_OPTION                ', clc$alias_entry, 7],
            ['LOAD_MAP_OPTIONS               ', clc$nominal_entry, 7],
            ['M                              ', clc$abbreviation_entry, 4],
            ['MODULE                         ', clc$alias_entry, 4],
            ['MODULES                        ', clc$nominal_entry, 4],
            ['P                              ', clc$abbreviation_entry, 2],
            ['PARAMETER                      ', clc$alias_entry, 2],
            ['PARAMETERS                     ', clc$nominal_entry, 2],
            ['PRESET_VALUE                   ', clc$nominal_entry, 8],
            ['PV                             ', clc$abbreviation_entry, 8],
            ['SP                             ', clc$abbreviation_entry, 5],
            ['SS                             ', clc$abbreviation_entry, 10],
            ['STACK_SIZE                     ', clc$nominal_entry, 10],
            ['STARTING_PROCEDURE             ', clc$nominal_entry, 5],
            ['STATUS                         ', clc$nominal_entry, 24],
            ['TASK_NAME                      ', clc$nominal_entry, 15],
            ['TEL                            ', clc$abbreviation_entry, 9],
            ['TERMINATION_ERROR_LEVEL        ', clc$nominal_entry, 9],
            ['TN                             ', clc$abbreviation_entry, 15]], [

{ PARAMETER 1

      [22, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 19, clc$optional_parameter, 0, 0],

{ PARAMETER 2

      [44, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 8, clc$optional_parameter, 0, 0],

{ PARAMETER 3

      [32, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 83, clc$optional_parameter, 0, 0],

{ PARAMETER 4

      [41, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 19, clc$optional_parameter, 0, 0],

{ PARAMETER 5

      [50, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0],

{ PARAMETER 6

      [36, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0],

{ PARAMETER 7

      [38, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 420, clc$optional_parameter, 0, 0],

{ PARAMETER 8

      [45, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 303, clc$optional_parameter, 0, 0],

{ PARAMETER 9

      [54, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 229, clc$optional_parameter, 0, 0],

{ PARAMETER 10

      [49, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 20, clc$optional_parameter, 0, 0],

{ PARAMETER 11

      [7, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0],

{ PARAMETER 12

      [9, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0],

{ PARAMETER 13

      [1, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0],

{ PARAMETER 14

      [8, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0],

{ PARAMETER 15

      [52, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 5, clc$optional_parameter, 0, 0],

{ PARAMETER 16

      [6, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0],

{ PARAMETER 17

      [5, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0],

{ PARAMETER 18

      [12, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0],

{ PARAMETER 19

      [17, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0],

{ PARAMETER 20

      [18, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0],

{ PARAMETER 21

      [26, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0],

{ PARAMETER 22

      [27, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0],

{ PARAMETER 23

      [30, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0],

{ PARAMETER 24

      [51, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name], clc$pass_by_reference, clc$immediate_evaluation,
            clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0]],

{ PARAMETER 1

      [[1, 0, clc$list_type], [3, 1, clc$max_list_size, FALSE], [[1, 0, clc$file_type]]],

{ PARAMETER 2

      [[1, 0, clc$string_type], [0, clc$max_string_size, FALSE]],

{ PARAMETER 3

      [[1, 0, clc$list_type], [67, 1, clc$max_list_size, FALSE],
            [[1, 0, clc$union_type], [[clc$file_type, clc$keyword_type], FALSE, 2], 44,
            [[1, 0, clc$keyword_type], [1], [['OSF$TASK_SERVICES_LIBRARY      ', clc$nominal_entry,
            clc$normal_usage_entry, 1]]], 3, [[1, 0, clc$file_type]]]],

{ PARAMETER 4

      [[1, 0, clc$list_type], [3, 1, clc$max_list_size, FALSE], [[1, 0, clc$program_name_type]]],

{ PARAMETER 5

      [[1, 0, clc$program_name_type]],

{ PARAMETER 6

      [[1, 0, clc$file_type]],

{ PARAMETER 7

      [[1, 0, clc$union_type], [[clc$keyword_type, clc$list_type], FALSE, 2], 81,
            [[1, 0, clc$keyword_type], [2], [['ALL                            ', clc$nominal_entry,
            clc$normal_usage_entry, 1], ['NONE                           ', clc$nominal_entry,
            clc$normal_usage_entry, 2]]], 319, [[1, 0, clc$list_type],
            [303, 1, clc$max_list_size, FALSE], [[1, 0, clc$keyword_type],
            [8], [['B                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
            ['BLOCK                          ', clc$nominal_entry, clc$normal_usage_entry, 2],
            ['CR                             ', clc$abbreviation_entry, clc$normal_usage_entry, 4],
            ['CROSS_REFERENCE                ', clc$nominal_entry, clc$normal_usage_entry, 4],
            ['ENTRY_POINT                    ', clc$nominal_entry, clc$normal_usage_entry, 3],
            ['EP                             ', clc$abbreviation_entry, clc$normal_usage_entry, 3],
            ['S                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
            ['SEGMENT                        ', clc$nominal_entry, clc$normal_usage_entry, 1]]]]],

{ PARAMETER 8

      [[1, 0, clc$keyword_type], [8], [['ALTERNATE_ONES                 ', clc$nominal_entry,
            clc$normal_usage_entry, 4], ['AO                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 4], ['FLOATING_POINT_INDEFINITE      ', clc$nominal_entry,
            clc$normal_usage_entry, 2], ['FPI                            ', clc$abbreviation_entry,
            clc$normal_usage_entry, 2], ['I                              ', clc$abbreviation_entry,
            clc$normal_usage_entry, 3], ['INFINITY                       ', clc$nominal_entry,
            clc$normal_usage_entry, 3], ['Z                              ', clc$abbreviation_entry,
            clc$normal_usage_entry, 1], ['ZERO                           ', clc$nominal_entry,
            clc$normal_usage_entry, 1]]],

{ PARAMETER 9

      [[1, 0, clc$keyword_type], [6], [['E                              ', clc$abbreviation_entry,
            clc$normal_usage_entry, 2], ['ERROR                          ', clc$nominal_entry,
            clc$normal_usage_entry, 2], ['F                              ', clc$abbreviation_entry,
            clc$normal_usage_entry, 3], ['FATAL                          ', clc$nominal_entry,
            clc$normal_usage_entry, 3], ['W                              ', clc$abbreviation_entry,
            clc$normal_usage_entry, 1], ['WARNING                        ', clc$nominal_entry,
            clc$normal_usage_entry, 1]]],

{ PARAMETER 10

      [[1, 0, clc$integer_type], [1, osc$max_segment_length, 10]],

{ PARAMETER 11

      [[1, 0, clc$file_type]],

{ PARAMETER 12

      [[1, 0, clc$file_type]],

{ PARAMETER 13

      [[1, 0, clc$file_type]],

{ PARAMETER 14

      [[1, 0, clc$boolean_type]],

{ PARAMETER 15

      [[1, 0, clc$name_type], [1, osc$max_name_size]],

{ PARAMETER 16

      [[1, 0, clc$boolean_type]],

{ PARAMETER 17

      [[1, 0, clc$boolean_type]],

{ PARAMETER 18

      [[1, 0, clc$boolean_type]],

{ PARAMETER 19

      [[1, 0, clc$boolean_type]],

{ PARAMETER 20

      [[1, 0, clc$boolean_type]],

{ PARAMETER 21

      [[1, 0, clc$boolean_type]],

{ PARAMETER 22

      [[1, 0, clc$boolean_type]],

{ PARAMETER 23

      [[1, 0, clc$boolean_type]],

{ PARAMETER 24

      [[1, 0, clc$status_type]]];

?? POP ??

    CONST
      p$files = 1,
      p$parameters = 2,
      p$libraries = 3,
      p$modules = 4,
      p$starting_procedure = 5,
      p$load_map = 6,
      p$load_map_options = 7,
      p$preset_value = 8,
      p$termination_error_level = 9,
      p$stack_size = 10,
      p$debug_input = 11,
      p$debug_output = 12,
      p$abort_file = 13,
      p$debug_mode = 14,
      p$task_name = 15,
      p$arithmetic_overflow = 16,
      p$arithmetic_loss_of_significan = 17 {ARITHMETIC_LOSS_OF_SIGNIFICANCE} ,
      p$divide_fault = 18,
      p$exponent_overflow = 19,
      p$exponent_underflow = 20,
      p$fp_indefinite = 21,
      p$fp_loss_of_significance = 22,
      p$invalid_bdp_data = 23,
      p$status = 24;

    VAR
      pvt: array [1 .. 24] of clt$parameter_value;

    VAR
      block: ^clt$block,
      caller_id: ost$caller_identifier,
      condition_specified: boolean,
      element: ^clt$data_value,
      enable_conditions: pmt$system_conditions,
      enable_inhibit_condition_size: 0 .. 1,
      enable_inhibit_conditions: ^pmt$enable_inhibit_conditions,
      file: clt$file,
      i: clt$list_size,
      inhibit_conditions: pmt$system_conditions,
      libraries: ^pmt$object_library_list,
      library_count: clt$list_size,
      map_option_count: clt$list_size,
      module_count: clt$list_size,
      modules: ^pmt$module_list,
      object_file_count: clt$list_size,
      object_files: ^pmt$object_file_list,
      parameters_p: ^record
        size: clt$parameter_list_text_size,
        value: clt$parameter_list_text,
      recend,
      program_attributes: ^pmt$program_attributes,
      program_descriptor: ^SEQ ( * ),
      search_mode: clt$command_search_modes,
      task_id: pmt$task_id,
      task_status: pmt$task_status,
      use_command_search_mode: boolean,
      value: ^clt$data_value;

    CONST
      ignore_command_file = osc$null_name;

    #CALLER_ID (caller_id);
    task_status.status.normal := TRUE;

    clp$find_current_block (block);
    use_command_search_mode := block^.use_command_search_mode;

    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    object_file_count := clp$count_list_elements (pvt [p$files].value);
    library_count := clp$count_list_elements (pvt [p$libraries].value);
    module_count := clp$count_list_elements (pvt [p$modules].value);

    enable_conditions := $pmt$system_conditions [];
    inhibit_conditions := $pmt$system_conditions [];

    IF pvt [p$arithmetic_overflow].specified THEN
      IF pvt [p$arithmetic_overflow].value^.boolean_value.value THEN
        enable_conditions := enable_conditions + $pmt$system_conditions [pmc$arithmetic_overflow];
      ELSE
        inhibit_conditions := inhibit_conditions + $pmt$system_conditions [pmc$arithmetic_overflow];
      IFEND;
    IFEND;

    IF pvt [p$arithmetic_loss_of_significan].specified THEN
      IF pvt [p$arithmetic_loss_of_significan].value^.boolean_value.value THEN
        enable_conditions := enable_conditions + $pmt$system_conditions [pmc$arithmetic_significance];
      ELSE
        inhibit_conditions := inhibit_conditions + $pmt$system_conditions [pmc$arithmetic_significance];
      IFEND;
    IFEND;

    IF pvt [p$divide_fault].specified THEN
      IF pvt [p$divide_fault].value^.boolean_value.value THEN
        enable_conditions := enable_conditions + $pmt$system_conditions [pmc$divide_fault];
      ELSE
        inhibit_conditions := inhibit_conditions + $pmt$system_conditions [pmc$divide_fault];
      IFEND;
    IFEND;

    IF pvt [p$exponent_overflow].specified THEN
      IF pvt [p$exponent_overflow].value^.boolean_value.value THEN
        enable_conditions := enable_conditions + $pmt$system_conditions [pmc$exponent_overflow];
      ELSE
        inhibit_conditions := inhibit_conditions + $pmt$system_conditions [pmc$exponent_overflow];
      IFEND;
    IFEND;

    IF pvt [p$exponent_underflow].specified THEN
      IF pvt [p$exponent_underflow].value^.boolean_value.value THEN
        enable_conditions := enable_conditions + $pmt$system_conditions [pmc$exponent_underflow];
      ELSE
        inhibit_conditions := inhibit_conditions + $pmt$system_conditions [pmc$exponent_underflow];
      IFEND;
    IFEND;

    IF pvt [p$fp_indefinite].specified THEN
      IF pvt [p$fp_indefinite].value^.boolean_value.value THEN
        enable_conditions := enable_conditions + $pmt$system_conditions [pmc$fp_indefinite];
      ELSE
        inhibit_conditions := inhibit_conditions + $pmt$system_conditions [pmc$fp_indefinite];
      IFEND;
    IFEND;

    IF pvt [p$fp_loss_of_significance].specified THEN
      IF pvt [p$fp_loss_of_significance].value^.boolean_value.value THEN
        enable_conditions := enable_conditions + $pmt$system_conditions [pmc$fp_significance_loss];
      ELSE
        inhibit_conditions := inhibit_conditions + $pmt$system_conditions [pmc$fp_significance_loss];
      IFEND;
    IFEND;

    IF pvt [p$invalid_bdp_data].specified THEN
      IF pvt [p$invalid_bdp_data].value^.boolean_value.value THEN
        enable_conditions := enable_conditions + $pmt$system_conditions [pmc$invalid_bdp_data];
      ELSE
        inhibit_conditions := inhibit_conditions + $pmt$system_conditions [pmc$invalid_bdp_data];
      IFEND;
    IFEND;

    condition_specified := (inhibit_conditions + enable_conditions) <> $pmt$system_conditions [];
    enable_inhibit_condition_size := $INTEGER (condition_specified);

    PUSH program_descriptor: [[REP (#SIZE (pmt$program_attributes) +
          ((object_file_count + library_count) * #SIZE (amt$local_file_name)) +
          (module_count * #SIZE (pmt$program_name)) + (enable_inhibit_condition_size *
          #SIZE (pmt$enable_inhibit_conditions))) OF cell]];
    RESET program_descriptor;
    NEXT program_attributes IN program_descriptor;
    program_attributes^.contents := $pmt$prog_description_contents [];

    IF pvt [p$starting_procedure].specified THEN
      program_attributes^.contents := program_attributes^.contents +
            $pmt$prog_description_contents [pmc$starting_proc_specified];
      program_attributes^.starting_procedure := pvt [p$starting_procedure].value^.program_name_value;
    IFEND;

    IF object_file_count > 0 THEN
      program_attributes^.contents := program_attributes^.contents +
            $pmt$prog_description_contents [pmc$object_file_list_specified];
      program_attributes^.number_of_object_files := object_file_count;
      NEXT object_files: [1 .. object_file_count] IN program_descriptor;
      value := pvt [p$files].value;
      FOR i := 1 TO object_file_count DO
        element := value^.element_value;
        clp$convert_string_to_file (element^.file_value^, file, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
        object_files^ [i] := file.local_file_name;
        value := value^.link;
      FOREND;
    IFEND;

    IF pvt [p$parameters].specified THEN
      PUSH parameters_p: [STRLENGTH (pvt [p$parameters].value^.string_value^)];
      parameters_p^.size := STRLENGTH (pvt [p$parameters].value^.string_value^);
      parameters_p^.value := pvt [p$parameters].value^.string_value^;
    ELSE
      PUSH parameters_p: [0];
      parameters_p^.size := 0;
      parameters_p^.value := '';
    IFEND;

    IF module_count > 0 THEN
      program_attributes^.contents := program_attributes^.contents +
            $pmt$prog_description_contents [pmc$module_list_specified];
      program_attributes^.number_of_modules := module_count;
      NEXT modules: [1 .. module_count] IN program_descriptor;
      value := pvt [p$modules].value;
      FOR i := 1 TO module_count DO
        modules^ [i] := value^.element_value^.program_name_value;
        value := value^.link;
      FOREND;
    IFEND;

    IF library_count > 0 THEN
      program_attributes^.contents := program_attributes^.contents +
            $pmt$prog_description_contents [pmc$library_list_specified];
      program_attributes^.number_of_libraries := library_count;
      NEXT libraries: [1 .. library_count] IN program_descriptor;
      value := pvt [p$libraries].value;
      FOR i := 1 TO library_count DO
        element := value^.element_value;
        IF element^.kind = clc$keyword THEN
          libraries^ [i] := element^.keyword_value;
        ELSE
          clp$convert_string_to_file (element^.file_value^, file, status);
          IF NOT status.normal THEN
            RETURN;
          IFEND;
          libraries^ [i] := file.local_file_name;
        IFEND;
        value := value^.link;
      FOREND;
    IFEND;

    IF pvt [p$load_map].specified THEN
      program_attributes^.contents := program_attributes^.contents +
            $pmt$prog_description_contents [pmc$load_map_file_specified];
      clp$convert_string_to_file (pvt [p$load_map].value^.file_value^, file, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      program_attributes^.load_map_file := file.local_file_name;
    IFEND;

    IF pvt [p$load_map_options].specified THEN
      program_attributes^.contents := program_attributes^.contents +
            $pmt$prog_description_contents [pmc$load_map_options_specified];
      get_load_map_options (pvt [p$load_map_options], program_attributes^.load_map_options, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
    IFEND;

    IF pvt [p$termination_error_level].specified THEN
      value := pvt [p$termination_error_level].value;
      program_attributes^.contents := program_attributes^.contents +
            $pmt$prog_description_contents [pmc$term_error_level_specified];
      IF value^.name_value = 'WARNING' THEN
        program_attributes^.termination_error_level := pmc$warning_load_errors;
      ELSEIF value^.name_value = 'ERROR' THEN
        program_attributes^.termination_error_level := pmc$error_load_errors;
      ELSEIF value^.name_value = 'FATAL' THEN
        program_attributes^.termination_error_level := pmc$fatal_load_errors;
      IFEND;
    IFEND;

    IF pvt [p$preset_value].specified THEN
      value := pvt [p$preset_value].value;
      program_attributes^.contents := program_attributes^.contents +
            $pmt$prog_description_contents [pmc$preset_specified];
      IF value^.name_value = 'FLOATING_POINT_INDEFINITE' THEN
        program_attributes^.preset := pmc$initialize_to_indefinite;
      ELSEIF value^.name_value = 'INFINITY' THEN
        program_attributes^.preset := pmc$initialize_to_infinity;
      ELSEIF value^.name_value = 'ALTERNATE_ONES' THEN
        program_attributes^.preset := pmc$initialize_to_alt_ones;
      ELSEIF value^.name_value = 'ZERO' THEN
        program_attributes^.preset := pmc$initialize_to_zero;
      IFEND;
    IFEND;

    IF pvt [p$stack_size].specified THEN
      program_attributes^.contents := program_attributes^.contents +
            $pmt$prog_description_contents [pmc$max_stack_size_specified];
      program_attributes^.maximum_stack_size := pvt [p$stack_size].value^.integer_value.value;
    IFEND;

    IF pvt [p$debug_input].specified THEN
      program_attributes^.contents := program_attributes^.contents +
            $pmt$prog_description_contents [pmc$debug_input_specified];
      clp$convert_string_to_file (pvt [p$debug_input].value^.file_value^, file, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      program_attributes^.debug_input := file.local_file_name;
    IFEND;

    IF pvt [p$debug_output].specified THEN
      program_attributes^.contents := program_attributes^.contents +
            $pmt$prog_description_contents [pmc$debug_output_specified];
      clp$convert_string_to_file (pvt [p$debug_output].value^.file_value^, file, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      program_attributes^.debug_output := file.local_file_name;
    IFEND;

    IF pvt [p$abort_file].specified THEN
      program_attributes^.contents := program_attributes^.contents +
            $pmt$prog_description_contents [pmc$abort_file_specified];
      clp$convert_string_to_file (pvt [p$abort_file].value^.file_value^, file, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      program_attributes^.abort_file := file.local_file_name;
    IFEND;

    IF pvt [p$debug_mode].specified THEN
      program_attributes^.contents := program_attributes^.contents +
            $pmt$prog_description_contents [pmc$debug_mode_specified];
      program_attributes^.debug_mode := pvt [p$debug_mode].value^.boolean_value.value;
    IFEND;

    IF condition_specified THEN
      NEXT enable_inhibit_conditions IN program_descriptor;
      program_attributes^.contents := program_attributes^.contents +
            $pmt$prog_description_contents [pmc$condition_specified];
      enable_inhibit_conditions^.enable_system_conditions := enable_conditions;
      enable_inhibit_conditions^.inhibit_system_conditions := inhibit_conditions;

    IFEND;


    clp$set_command_kind (clc$command_is_execute_task);

    IF pvt [p$task_name].specified THEN

{ Asynchronous execute.

      clp$get_command_search_mode (search_mode);
      IF (search_mode = clc$exclusive_command_search) AND use_command_search_mode THEN
        osp$set_status_abnormal ('CL', cle$not_allowed_in_exclusive, 'EXECUTE_TASK', status);
        RETURN;
      IFEND;

      clp$execute_named_task (pvt [p$task_name].value^.name_value, caller_id.ring, program_descriptor^,
            #SEQ (parameters_p^) ^, ignore_command_file, task_id, status);
    ELSE

{ Synchronous execute.

      pmp$execute (program_descriptor^, #SEQ (parameters_p^) ^, osc$wait, task_id, task_status, status);
      IF status.normal AND (NOT task_status.status.normal) THEN
        status := task_status.status;
      IFEND;
    IFEND;

  PROCEND pmp$_execute_task;
?? TITLE := '[XDCL] pmp$_terminate_task', EJECT ??

{ PURPOSE:
{  This is the command processor for the terminate_task command.
{

  PROCEDURE [XDCL] pmp$_terminate_task
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE (osm$tert) terminate_task, tert (
{   task_name, task_names, tn: any of
{       key
{         all
{       keyend
{       list of name
{     anyend = $required
{   status)

?? PUSH (LISTEXT := ON) ??

    VAR
      pdt: [STATIC, READ, cls$declaration_section] record
        header: clt$pdt_header,
        names: array [1 .. 4] of clt$pdt_parameter_name,
        parameters: array [1 .. 2] of clt$pdt_parameter,
        type1: record
          header: clt$type_specification_header,
          qualifier: clt$union_type_qualifier,
          type_size_1: clt$type_specification_size,
          element_type_spec_1: record
            header: clt$type_specification_header,
            qualifier: clt$keyword_type_qualifier,
            keyword_specs: array [1 .. 1] of clt$keyword_specification,
          recend,
          type_size_2: clt$type_specification_size,
          element_type_spec_2: record
            header: clt$type_specification_header,
            qualifier: clt$list_type_qualifier,
            element_type_spec: record
              header: clt$type_specification_header,
              qualifier: clt$name_type_qualifier,
            recend,
          recend,
        recend,
        type2: record
          header: clt$type_specification_header,
        recend,
      recend := [[1, [88, 9, 26, 14, 35, 47, 676], clc$command, 4, 2, 1, 0, 0, 0, 2, 'OSM$TERT'],
            [['STATUS                         ', clc$nominal_entry, 2],
            ['TASK_NAME                      ', clc$nominal_entry, 1],
            ['TASK_NAMES                     ', clc$alias_entry, 1],
            ['TN                             ', clc$abbreviation_entry, 1]], [

{ PARAMETER 1

      [2, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 85, clc$required_parameter, 0, 0],

{ PARAMETER 2

      [1, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods [clc$specify_by_name],
            clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
            clc$optional_parameter, 0, 0]],

{ PARAMETER 1

      [[1, 0, clc$union_type], [[clc$keyword_type, clc$list_type], FALSE, 2], 44,
            [[1, 0, clc$keyword_type], [1], [['ALL                            ', clc$nominal_entry,
            clc$normal_usage_entry, 1]]], 21, [[1, 0, clc$list_type],
            [5, 1, clc$max_list_size, FALSE], [[1, 0, clc$name_type], [1, osc$max_name_size]]]],

{ PARAMETER 2

      [[1, 0, clc$status_type]]];

?? POP ??

    CONST
      p$task_name = 1,
      p$status = 2;

    VAR
      pvt: array [1 .. 2] of clt$parameter_value;

?? NEWTITLE := 'check_parent_and_tert', EJECT ??

    PROCEDURE [INLINE] check_parent_and_tert
      (    task_name: ost$name;
           all: boolean;
       VAR status {input, output} : ost$status);

      VAR
        terminate_status: ost$status;

      terminate_status.normal := TRUE;

      WHILE task_name <> named_task.name DO
        IF NOT (named_task.link = NIL) THEN
          named_task := named_task.link^
        ELSE
          IF status.normal THEN
            osp$set_status_abnormal ('CL', cle$task_not_found, task_name, status);
          ELSEIF status.condition = cle$task_not_found THEN
            osp$append_status_parameter (' ', task_name, status);
          IFEND;
          RETURN;
        IFEND;
      WHILEND;

      IF current_task_id = named_task.parent_task_id THEN
        IF NOT named_task.status.complete THEN
          pmp$terminate (named_task.id, terminate_status);
          IF NOT terminate_status.normal THEN
            IF status.normal THEN
              status := terminate_status;
            ELSEIF status.condition = terminate_status.condition THEN
              osp$append_status_parameter (osc$status_parameter_delimiter, task_name, status);
            IFEND;
          IFEND;
        ELSEIF NOT all THEN
          IF status.normal THEN
            osp$set_status_abnormal ('CL', cle$task_already_complete, task_name, status);
          ELSEIF status.condition = cle$task_already_complete THEN
            osp$append_status_parameter (' ', task_name, status);
          IFEND;
        IFEND;
      ELSEIF NOT all THEN
        IF status.normal THEN
          osp$set_status_abnormal ('CL', cle$task_not_found, task_name, status);
        ELSEIF status.condition = cle$task_not_found THEN
          osp$append_status_parameter (' ', task_name, status);
        IFEND;
      IFEND;

    PROCEND check_parent_and_tert;
?? OLDTITLE, EJECT ??

    VAR
      current_task_id: pmt$task_id,
      named_task: clt$named_task,
      named_task_list: ^clt$named_task,
      named_task_group_list: ^^clt$named_task,
      value: ^clt$data_value;

    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    pmp$get_task_id (current_task_id, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    value := pvt [p$task_name].value;
    IF value^.kind = clc$keyword { ALL} THEN
      clp$find_named_task_group_list (named_task_group_list);
      named_task_list := named_task_group_list^;
      WHILE named_task_list <> NIL DO
        named_task := named_task_list^;
        check_parent_and_tert (named_task_list^.name, TRUE, status);
        named_task_list := named_task_list^.link;
      WHILEND;
    ELSE
      WHILE value <> NIL DO
        IF value^.element_value <> NIL THEN
          clp$fetch_named_task_entry (value^.element_value^.name_value, named_task);
          check_parent_and_tert (value^.element_value^.name_value, FALSE, status);
        IFEND;
        value := value^.link;
      WHILEND;
    IFEND;

  PROCEND pmp$_terminate_task;
?? TITLE := '[XDCL] pmp$_display_program_attributes', EJECT ??

{ PURPOSE:
{  This is the command processor for the display_program_attribute command.
{

  PROCEDURE [XDCL] pmp$_display_program_attributes
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

    CONST
      max_program_attb_name_size = 31;

{ PROCEDURE (osm$dispa) display_program_attributes, display_program_attribute, dispa (
{   output, o: file = $output
{   status)

?? PUSH (LISTEXT := ON) ??

    VAR
      pdt: [STATIC, READ, cls$declaration_section] record
        header: clt$pdt_header,
        names: array [1 .. 3] of clt$pdt_parameter_name,
        parameters: array [1 .. 2] of clt$pdt_parameter,
        type1: record
          header: clt$type_specification_header,
          default_value: string (7),
        recend,
        type2: record
          header: clt$type_specification_header,
        recend,
      recend := [[1, [88, 9, 26, 14, 36, 36, 578], clc$command, 3, 2, 0, 0, 0, 0, 2, 'OSM$DISPA'],
            [['O                              ', clc$abbreviation_entry, 1],
            ['OUTPUT                         ', clc$nominal_entry, 1],
            ['STATUS                         ', clc$nominal_entry, 2]], [

{ PARAMETER 1

      [2, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods
            [clc$specify_by_name, clc$specify_positionally], clc$pass_by_value, clc$immediate_evaluation,
            clc$standard_parameter_checking, 3, clc$optional_default_parameter, 0, 7],

{ PARAMETER 2

      [3, clc$normal_usage_entry, clc$non_secure_parameter, $clt$parameter_spec_methods [clc$specify_by_name],
            clc$pass_by_reference, clc$immediate_evaluation, clc$standard_parameter_checking, 3,
            clc$optional_parameter, 0, 0]],

{ PARAMETER 1

      [[1, 0, clc$file_type], '$output'],

{ PARAMETER 2

      [[1, 0, clc$status_type]]];

?? POP ??

    CONST
      p$output = 1,
      p$status = 2;

    VAR
      pvt: array [1 .. 2] of clt$parameter_value;

*copy clv$display_variables
?? NEWTITLE := 'abort_handler', EJECT ??

    PROCEDURE abort_handler
      (    condition: pmt$condition;
           condition_information: ^pmt$condition_information;
           save_area: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);

      VAR
        ignore_status: ost$status;

      clp$close_display (display_control, ignore_status);

    PROCEND abort_handler;
*copy clp$new_page_procedure
?? TITLE := 'put_subtitle', EJECT ??

    PROCEDURE [INLINE] put_subtitle
      (VAR display_control: clt$display_control;
       VAR status: ost$status);

{ The display_program command has no subtitles,
{ this is merely a dummy routine used to keep
{ the module consistent with those that do produce subtitles.

    PROCEND put_subtitle;
?? TITLE := 'put_attribute', EJECT ??

    PROCEDURE put_attribute
      (    header: string ( * );
           value: string ( * ));

      VAR
        edited_header: string (tab_over),
        start_option: amt$term_option;

      CONST
        tab_over = max_program_attb_name_size + 5;

      status.normal := TRUE;
      start_option := amc$start;
      edited_header := header;
      edited_header (tab_over - 2) := ':';

      clp$put_partial_display (display_control, edited_header, clc$no_trim, start_option, status);
      IF NOT status.normal THEN
        EXIT pmp$_display_program_attributes
      IFEND;
      clp$put_partial_display (display_control, value, clc$trim, amc$terminate, status);
      IF NOT status.normal THEN
        EXIT pmp$_display_program_attributes
      IFEND;

    PROCEND put_attribute;
?? TITLE := 'put_attribute_list', EJECT ??

    PROCEDURE put_attribute_list
      (    header: string ( * );
           value_count: integer;
           value: array [ * ] of string (osc$max_name_size));

      VAR
        edited_header: string (tab_over),
        start_option: amt$term_option,
        value_index: integer;

      CONST
        tab_over = max_program_attb_name_size + 6;

      status.normal := TRUE;
      start_option := amc$start;
      edited_header := header;
      edited_header (tab_over) := '(';
      edited_header (tab_over - 3) := ':';

      clp$put_partial_display (display_control, edited_header, clc$no_trim, start_option, status);
      IF NOT status.normal THEN
        EXIT pmp$_display_program_attributes
      IFEND;

      FOR value_index := 1 TO value_count DO
        IF (display_control.column_number + clp$trimmed_string_size (value [value_index]) + 2) >
              clv$page_width THEN
          clp$new_display_line (display_control, clc$next_display_line, status);
          IF NOT status.normal THEN
            EXIT pmp$_display_program_attributes
          IFEND;
          clp$horizontal_tab_display (display_control, tab_over, status);
          IF NOT status.normal THEN
            EXIT pmp$_display_program_attributes
          IFEND;
        IFEND;
        clp$put_partial_display (display_control, value [value_index], clc$trim, amc$continue, status);
        IF NOT status.normal THEN
          EXIT pmp$_display_program_attributes
        IFEND;
        IF value_index = value_count THEN
          clp$put_partial_display (display_control, ')', clc$no_trim, amc$terminate, status);
          IF NOT status.normal THEN
            EXIT pmp$_display_program_attributes
          IFEND;
        ELSE
          clp$put_partial_display (display_control, ', ', clc$no_trim, amc$continue, status);
          IF NOT status.normal THEN
            EXIT pmp$_display_program_attributes
          IFEND;
        IFEND;
      FOREND;

    PROCEND put_attribute_list;
?? TITLE := 'put_path_name_list', EJECT ??

    PROCEDURE put_path_name_list
      (    header: string ( * );
           path_array: array [1 .. * ] of fst$path);

      VAR
        chunk_index: integer,
        edited_header: string (tab_over),
        end_delimeter: string (1),
        path_name: fst$path,
        path_name_index: integer,
        path_name_size: 1 .. fsc$max_path_size,
        start_delimeter: string (1),
        start_option: amt$term_option;

      CONST
        tab_over = max_program_attb_name_size + 5;

      status.normal := TRUE;
      start_option := amc$start;
      edited_header := header;
      edited_header (tab_over - 2) := ':';

      clp$put_partial_display (display_control, edited_header, clc$no_trim, start_option, status);
      IF NOT status.normal THEN
        EXIT pmp$_display_program_attributes;
      IFEND;

      IF UPPERBOUND (path_array) = 1 THEN
        end_delimeter := ' ';
      ELSE
        clp$put_partial_display (display_control, '(', clc$trim, amc$continue, status);
        IF NOT status.normal THEN
          EXIT pmp$_display_program_attributes
        IFEND;
        end_delimeter := ')';
      IFEND;

      FOR path_name_index := 1 TO UPPERBOUND (path_array) DO
        path_name := path_array [path_name_index];
        path_name_size := clp$trimmed_string_size (path_array [path_name_index]);

        clp$build_path_subtitle (path_name, path_name_size, (clv$page_width - tab_over),
              clv$path_display_chunk_count, clv$path_display_chunks);

        FOR chunk_index := 1 TO clv$path_display_chunk_count DO
          clp$put_partial_display (display_control, path_name
                (clv$path_display_chunks [chunk_index].position, clv$path_display_chunks [chunk_index].
                length), clc$trim, amc$continue, status);
          IF NOT status.normal THEN
            EXIT pmp$_display_program_attributes
          IFEND;

          IF chunk_index = clv$path_display_chunk_count THEN
            IF path_name_index = UPPERBOUND (path_array) THEN
              clp$put_partial_display (display_control, end_delimeter, clc$trim, amc$terminate, status);
              IF NOT status.normal THEN
                EXIT pmp$_display_program_attributes
              IFEND;
            ELSE
              clp$put_partial_display (display_control, ',', clc$trim, amc$terminate, status);
              IF NOT status.normal THEN
                EXIT pmp$_display_program_attributes
              IFEND;
              clp$new_display_line (display_control, clc$next_display_line, status);
              IF NOT status.normal THEN
                EXIT pmp$_display_program_attributes
              IFEND;
              clp$horizontal_tab_display (display_control, (tab_over + 1), status);
              IF NOT status.normal THEN
                EXIT pmp$_display_program_attributes
              IFEND;
            IFEND;
          ELSE
            clp$put_partial_display (display_control, '..', clc$trim, amc$terminate, status);
            IF NOT status.normal THEN
              EXIT pmp$_display_program_attributes
            IFEND;
            clp$new_display_line (display_control, clc$next_display_line, status);
            IF NOT status.normal THEN
              EXIT pmp$_display_program_attributes
            IFEND;
            clp$horizontal_tab_display (display_control, (tab_over + 1), status);
            IF NOT status.normal THEN
              EXIT pmp$_display_program_attributes
            IFEND;
          IFEND;
        FOREND;
      FOREND;

    PROCEND put_path_name_list;
?? OLDTITLE, EJECT ??

    CONST
      max_map_option_string_size = 16, { cross_reference
      max_boolean_string_size = 3; {off

    VAR
      map_option_string: [STATIC, READ, oss$job_paged_literal] array
            [pmc$no_load_map .. pmc$entry_point_xref] of string (max_map_option_string_size) := ['none',
            'segment', 'block', 'entry_point', 'cross_reference'],
      boolean_string: [STATIC, READ, oss$job_paged_literal] array [boolean] of
            string (max_boolean_string_size) := ['off', 'on'];

    VAR
      attribute_array: array [1 .. 5] of ost$name,
      condition_enabled: boolean,
      debug_library_list: ^pmt$object_library_list,
      debug_mode: ost$string,
      default_program_options: pmt$program_options,
      default_ring_attributes: amt$ring_attributes,
      display_control: clt$display_control,
      file_reference: fst$path,
      i: pmt$number_of_libraries,
      ignore_status: ost$status,
      initialization_value: pmt$initialization_value,
      job_library_list: ^pmt$object_library_list,
      map_option: pmc$no_load_map .. pmc$entry_point_xref,
      number_of_libraries: pmt$number_of_libraries,
      number_string: ost$string,
      path_name_array: ^array [1 .. * ] of fst$path,
      prog_options_and_libraries: ^pmt$prog_options_and_libraries,
      value_count: integer;

    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    display_control := clv$nil_display_control;
    #SPOIL (display_control);
    osp$establish_block_exit_hndlr (^abort_handler);

    default_ring_attributes.r1 := #RING (^default_ring_attributes);
    default_ring_attributes.r2 := #RING (^default_ring_attributes);
    default_ring_attributes.r3 := #RING (^default_ring_attributes);
    clp$open_display_reference (pvt [p$output].value^.file_value^, ^clp$new_page_procedure, fsc$list,
          default_ring_attributes, display_control, status);
    IF NOT status.normal THEN
      osp$disestablish_cond_handler;
      RETURN;
    IFEND;
    clv$titles_built := FALSE;
    clv$command_name := 'display_program_attributes';

    IF display_control.page_width < clc$narrow_page_width THEN
      clv$page_width := clc$narrow_page_width;
    ELSEIF display_control.page_width > clc$wide_page_width THEN
      clv$page_width := clc$wide_page_width;
    ELSE
      clv$page_width := display_control.page_width;
    IFEND;


    pmp$find_prog_options_and_libs (prog_options_and_libraries);
    job_library_list := prog_options_and_libraries^.job_library_list;
    debug_library_list := prog_options_and_libraries^.debug_library_list;
    default_program_options := prog_options_and_libraries^.default_options^;

    IF job_library_list = NIL THEN
      put_attribute ('Libraries', 'None');
    ELSE
      number_of_libraries := UPPERBOUND (job_library_list^);
      PUSH path_name_array: [1 .. number_of_libraries];
      FOR i := 1 TO number_of_libraries DO
        IF job_library_list^ [i] = 'OSF$TASK_SERVICES_LIBRARY' THEN
          path_name_array^ [i] := 'osf$task_services_library';
        ELSE
          clp$get_path_name (job_library_list^ [i], osc$full_message_level, file_reference);
          path_name_array^ [i] := file_reference;
        IFEND;
      FOREND;
      put_path_name_list ('Libraries', path_name_array^);
    IFEND;

    IF debug_library_list = NIL THEN
      put_attribute ('Debug_Libraries', 'None');
    ELSE
      number_of_libraries := UPPERBOUND (debug_library_list^);
      PUSH path_name_array: [1 .. number_of_libraries];
      FOR i := 1 TO number_of_libraries DO
        clp$get_path_name (debug_library_list^ [i], osc$full_message_level, file_reference);
        path_name_array^ [i] := file_reference;
      FOREND;
      put_path_name_list ('Debug_Libraries', path_name_array^);
    IFEND;

    PUSH path_name_array: [1 .. 1];
    clp$get_path_name (default_program_options.map_file, osc$full_message_level, file_reference);
    path_name_array^ [1] := file_reference;
    put_path_name_list ('Load_Map', path_name_array^);

    value_count := 0;
    FOR map_option := pmc$no_load_map TO pmc$entry_point_xref DO
      IF map_option IN default_program_options.map_options THEN
        value_count := value_count + 1;
        attribute_array [value_count] := map_option_string [map_option];
      IFEND;
    FOREND;
    IF value_count = 0 THEN
      put_attribute ('Load_Map_Options', 'None');
    ELSE
      put_attribute_list ('Load_Map_Options', value_count, attribute_array);
    IFEND;

    put_attribute ('Termination_Error_Level', termination_error_level_string
          [default_program_options.termination_error_level]);

  /display_preset/
    BEGIN
      FOR initialization_value := pmc$initialize_to_zero TO pmc$initialize_to_infinity DO
        IF default_program_options.preset = pmv$preset_conversion_table [initialization_value] THEN
          put_attribute ('Preset_Value', preset_string [initialization_value]);
          EXIT /display_preset/;
        IFEND;
      FOREND;
      clp$convert_integer_to_string (default_program_options.preset, 16, TRUE, number_string, ignore_status);
      put_attribute ('Preset_Value', number_string.value (1, number_string.size));
    END /display_preset/;

    clp$convert_integer_to_string (default_program_options.maximum_stack_size, 10, FALSE, number_string,
          ignore_status);
    put_attribute ('Maximum_Stack_Size', number_string.value (1, number_string.size));

    clp$convert_integer_to_string (pmp$job_debug_ring (), 10, FALSE, number_string, ignore_status);
    put_attribute ('Debug_Ring', number_string.value (1, number_string.size));

{ The following code prevents the full permanent file path name of the command file from being displayed,
{ in the case where the debug_input file corresponds to the default command file.  We do not want users
{ to see the name of the file in the input queue.

    IF default_program_options.debug_input = clv$standard_files [clc$sf_command_file].path_handle_name THEN
      path_name_array^ [1] := ':$local.command.1';
    ELSE
      clp$get_path_name (default_program_options.debug_input, osc$full_message_level, file_reference);
      path_name_array^ [1] := file_reference;
    IFEND;
    put_path_name_list ('Debug_Input', path_name_array^);

    clp$get_path_name (default_program_options.debug_output, osc$full_message_level, file_reference);
    path_name_array^ [1] := file_reference;
    put_path_name_list ('Debug_Output', path_name_array^);

    clp$get_path_name (default_program_options.abort_file, osc$full_message_level, file_reference);
    path_name_array^ [1] := file_reference;
    put_path_name_list ('Abort_File', path_name_array^);

    put_attribute ('Debug_Mode', boolean_string [default_program_options.debug_mode]);

    condition_enabled := (pmc$arithmetic_overflow IN default_program_options.conditions_enabled);
    put_attribute ('Arithmetic_Overflow', boolean_string [condition_enabled]);

    condition_enabled := (pmc$arithmetic_significance IN default_program_options.conditions_enabled);
    put_attribute ('Arithmetic_Loss_of_Significance', boolean_string [condition_enabled]);

    condition_enabled := (pmc$divide_fault IN default_program_options.conditions_enabled);
    put_attribute ('Divide_Fault', boolean_string [condition_enabled]);

    condition_enabled := (pmc$exponent_overflow IN default_program_options.conditions_enabled);
    put_attribute ('Exponent_Overflow', boolean_string [condition_enabled]);

    condition_enabled := (pmc$exponent_underflow IN default_program_options.conditions_enabled);
    put_attribute ('Exponent_Underflow', boolean_string [condition_enabled]);

    condition_enabled := (pmc$fp_indefinite IN default_program_options.conditions_enabled);
    put_attribute ('FP_Indefinite', boolean_string [condition_enabled]);

    condition_enabled := (pmc$fp_significance_loss IN default_program_options.conditions_enabled);
    put_attribute ('FP_Loss_of_Significance', boolean_string [condition_enabled]);

    condition_enabled := (pmc$invalid_bdp_data IN default_program_options.conditions_enabled);
    put_attribute ('Invalid_BDP_Data', boolean_string [condition_enabled]);

    clp$close_display (display_control, status);

    osp$disestablish_cond_handler;

  PROCEND pmp$_display_program_attributes;
?? TITLE := '[XDCL] pmp$$program', EJECT ??

{ PURPOSE:
{  This is the command processor for $program function.
{

  PROCEDURE [XDCL] pmp$$program
    (    parameter_list: clt$parameter_list;
     VAR work_area {input, output} : ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

{ FUNCTION (osm$program) $program (
{   attribute: key
{      (abort_file, af),
{      (arithmetic_loss_of_significance, alos),
{      (arithmetic_overflow, ao),
{      (debug_input, di),
{      (debug_mode, dm),
{      (debug_output, do),
{      (divide_fault, df),
{      (exponent_overflow, eo),
{      (exponent_underflow, eu),
{      (fp_indefinite, fpi, fi),
{      (fp_loss_of_significance, fplos, flos),
{      (invalid_bdp_data, ibdpd, ibd),
{      (load_map, lm),
{      (load_map_option, load_map_options, lmo),
{      (preset_value, pv),
{      (termination_error_level, tel),
{     keyend = $required
{   load_map_option: key
{       (block, b), (cross_reference, cr), (entry_point, ep),
{       (none), (segment, s)
{     keyend
{  )

?? PUSH (LISTEXT := ON) ??

    VAR
      pdt: [STATIC, READ, cls$declaration_section] record
        header: clt$pdt_header,
        names: array [1 .. 2] of clt$pdt_parameter_name,
        parameters: array [1 .. 2] of clt$pdt_parameter,
        type1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 36] of clt$keyword_specification,
        recend,
        type2: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 9] of clt$keyword_specification,
        recend,
      recend := [[1, [88, 9, 26, 14, 33, 41, 87], clc$function, 2, 2, 1, 0, 0, 0, 0, 'OSM$PROGRAM'],
            [['ATTRIBUTE                      ', clc$nominal_entry, 1],
            ['LOAD_MAP_OPTION                ', clc$nominal_entry, 2]], [

{ PARAMETER 1

      [1, clc$normal_usage_entry, clc$non_secure_parameter,
            $clt$parameter_spec_methods [clc$specify_positionally], clc$pass_by_value,
            clc$immediate_evaluation, clc$standard_parameter_checking, 1339, clc$required_parameter, 0, 0],

{ PARAMETER 2

      [2, clc$normal_usage_entry, clc$non_secure_parameter,
            $clt$parameter_spec_methods [clc$specify_positionally], clc$pass_by_value,
            clc$immediate_evaluation, clc$standard_parameter_checking, 340, clc$optional_parameter, 0, 0]],

{ PARAMETER 1

      [[1, 0, clc$keyword_type], [36], [['ABORT_FILE                     ', clc$nominal_entry,
            clc$normal_usage_entry, 1], ['AF                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 1], ['ALOS                           ', clc$abbreviation_entry,
            clc$normal_usage_entry, 2], ['AO                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 3], ['ARITHMETIC_LOSS_OF_SIGNIFICANCE', clc$nominal_entry,
            clc$normal_usage_entry, 2], ['ARITHMETIC_OVERFLOW            ', clc$nominal_entry,
            clc$normal_usage_entry, 3], ['DEBUG_INPUT                    ', clc$nominal_entry,
            clc$normal_usage_entry, 4], ['DEBUG_MODE                     ', clc$nominal_entry,
            clc$normal_usage_entry, 5], ['DEBUG_OUTPUT                   ', clc$nominal_entry,
            clc$normal_usage_entry, 6], ['DF                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 7], ['DI                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 4], ['DIVIDE_FAULT                   ', clc$nominal_entry,
            clc$normal_usage_entry, 7], ['DM                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 5], ['DO                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 6], ['EO                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 8], ['EU                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 9], ['EXPONENT_OVERFLOW              ', clc$nominal_entry,
            clc$normal_usage_entry, 8], ['EXPONENT_UNDERFLOW             ', clc$nominal_entry,
            clc$normal_usage_entry, 9], ['FI                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 10], ['FLOS                           ', clc$abbreviation_entry,
            clc$normal_usage_entry, 11], ['FPI                            ', clc$alias_entry,
            clc$normal_usage_entry, 10], ['FPLOS                          ', clc$alias_entry,
            clc$normal_usage_entry, 11], ['FP_INDEFINITE                  ', clc$nominal_entry,
            clc$normal_usage_entry, 10], ['FP_LOSS_OF_SIGNIFICANCE        ', clc$nominal_entry,
            clc$normal_usage_entry, 11], ['IBD                            ', clc$abbreviation_entry,
            clc$normal_usage_entry, 12], ['IBDPD                          ', clc$alias_entry,
            clc$normal_usage_entry, 12], ['INVALID_BDP_DATA               ', clc$nominal_entry,
            clc$normal_usage_entry, 12], ['LM                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 13], ['LMO                            ', clc$abbreviation_entry,
            clc$normal_usage_entry, 14], ['LOAD_MAP                       ', clc$nominal_entry,
            clc$normal_usage_entry, 13], ['LOAD_MAP_OPTION                ', clc$nominal_entry,
            clc$normal_usage_entry, 14], ['LOAD_MAP_OPTIONS               ', clc$alias_entry,
            clc$normal_usage_entry, 14], ['PRESET_VALUE                   ', clc$nominal_entry,
            clc$normal_usage_entry, 15], ['PV                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 15], ['TEL                            ', clc$abbreviation_entry,
            clc$normal_usage_entry, 16], ['TERMINATION_ERROR_LEVEL        ', clc$nominal_entry,
            clc$normal_usage_entry, 16]]],

{ PARAMETER 2

      [[1, 0, clc$keyword_type], [9], [['B                              ', clc$abbreviation_entry,
            clc$normal_usage_entry, 1], ['BLOCK                          ', clc$nominal_entry,
            clc$normal_usage_entry, 1], ['CR                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 2], ['CROSS_REFERENCE                ', clc$nominal_entry,
            clc$normal_usage_entry, 2], ['ENTRY_POINT                    ', clc$nominal_entry,
            clc$normal_usage_entry, 3], ['EP                             ', clc$abbreviation_entry,
            clc$normal_usage_entry, 3], ['NONE                           ', clc$nominal_entry,
            clc$normal_usage_entry, 4], ['S                              ', clc$abbreviation_entry,
            clc$normal_usage_entry, 5], ['SEGMENT                        ', clc$nominal_entry,
            clc$normal_usage_entry, 5]]]];

?? POP ??

    CONST
      p$attribute = 1,
      p$load_map_option = 2;

    VAR
      pvt: array [1 .. 2] of clt$parameter_value;

    VAR
      attribute_name: ost$name,
      default_program_options: pmt$program_options,
      initialization_value: pmt$initialization_value,
      map_option_enabled: boolean,
      path: fst$path,
      prog_options_and_libraries: ^pmt$prog_options_and_libraries,
      translated_string: string (osc$max_name_size);

    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    pmp$find_prog_options_and_libs (prog_options_and_libraries);
    default_program_options := prog_options_and_libraries^.default_options^;

    attribute_name := pvt [p$attribute].value^.name_value;
    IF attribute_name = 'LOAD_MAP_OPTION' THEN
      IF NOT pvt [p$load_map_option].specified THEN
        osp$set_status_abnormal ('CL', cle$required_argument_omitted, '$PROGRAM(LOAD_MAP_OPTION,)', status);
        osp$append_status_parameter (osc$status_parameter_delimiter, '2', status);

      ELSE
        IF pvt [p$load_map_option].value^.name_value = 'SEGMENT' THEN
          map_option_enabled := pmc$segment_map IN default_program_options.map_options;
        ELSEIF pvt [p$load_map_option].value^.name_value = 'BLOCK' THEN
          map_option_enabled := pmc$block_map IN default_program_options.map_options;
        ELSEIF pvt [p$load_map_option].value^.name_value = 'ENTRY_POINT' THEN
          map_option_enabled := pmc$entry_point_map IN default_program_options.map_options;
        ELSEIF pvt [p$load_map_option].value^.name_value = 'CROSS_REFERENCE' THEN
          map_option_enabled := pmc$entry_point_xref IN default_program_options.map_options;
        ELSE {IF pvt [p$load_map_option].value^.name_value = 'NONE' THEN }
          map_option_enabled := $pmt$load_map_options [] = default_program_options.map_options;
        IFEND;
        clp$make_boolean_value (map_option_enabled, clc$true_false_boolean, work_area, result);
      IFEND;

    ELSEIF pvt [p$load_map_option].specified THEN
      osp$set_status_abnormal ('CL', cle$too_many_arguments, '$PROGRAM', status);

    ELSEIF attribute_name = 'LOAD_MAP' THEN
      clp$get_path_name (default_program_options.map_file, osc$full_message_level, path);
      clp$make_file_value (path, work_area, result);

    ELSEIF attribute_name = 'PRESET_VALUE' THEN

    /return_preset/
      BEGIN
        FOR initialization_value := pmc$initialize_to_zero TO pmc$initialize_to_infinity DO
          IF default_program_options.preset = pmv$preset_conversion_table [initialization_value] THEN
            #TRANSLATE (osv$lower_to_upper, preset_string [initialization_value], translated_string);
            EXIT /return_preset/;
          IFEND;
        FOREND;
        translated_string := 'NON_STANDARD';
      END /return_preset/;
      clp$make_sized_string_value (clp$trimmed_string_size (translated_string), work_area, result);
      result^.string_value^ := translated_string;

    ELSEIF attribute_name = 'TERMINATION_ERROR_LEVEL' THEN
      #TRANSLATE (osv$lower_to_upper, termination_error_level_string
            [default_program_options.termination_error_level], translated_string);
      clp$make_sized_string_value (clp$trimmed_string_size (translated_string), work_area, result);
      result^.string_value^ := translated_string;

    ELSEIF attribute_name = 'DEBUG_INPUT' THEN

{ The following code prevents the full permanent file path name of the command file from being displayed,
{ in the case where the debug_input file corresponds to the default command file.  We do not want users
{ to see the name of the file in the input queue.

      IF default_program_options.debug_input = clv$standard_files [clc$sf_command_file].path_handle_name THEN
        path := ':$LOCAL.COMMAND.1';
      ELSE
        clp$get_path_name (default_program_options.debug_input, osc$full_message_level, path);
      IFEND;
      clp$make_file_value (path, work_area, result);

    ELSEIF attribute_name = 'DEBUG_OUTPUT' THEN
      clp$get_path_name (default_program_options.debug_output, osc$full_message_level, path);
      clp$make_file_value (path, work_area, result);

    ELSEIF attribute_name = 'ABORT_FILE' THEN
      clp$get_path_name (default_program_options.abort_file, osc$full_message_level, path);
      clp$make_file_value (path, work_area, result);

    ELSEIF attribute_name = 'DEBUG_MODE' THEN
      clp$make_boolean_value (default_program_options.debug_mode, clc$true_false_boolean, work_area, result);

    ELSEIF attribute_name = 'ARITHMETIC_OVERFLOW' THEN
      clp$make_boolean_value (pmc$arithmetic_overflow IN default_program_options.conditions_enabled,
            clc$true_false_boolean, work_area, result);

    ELSEIF attribute_name = 'ARITHMETIC_LOSS_OF_SIGNIFICANCE' THEN
      clp$make_boolean_value (pmc$arithmetic_significance IN default_program_options.conditions_enabled,
            clc$true_false_boolean, work_area, result);

    ELSEIF attribute_name = 'DIVIDE_FAULT' THEN
      clp$make_boolean_value (pmc$divide_fault IN default_program_options.conditions_enabled,
            clc$true_false_boolean, work_area, result);

    ELSEIF attribute_name = 'EXPONENT_OVERFLOW' THEN
      clp$make_boolean_value (pmc$exponent_overflow IN default_program_options.conditions_enabled,
            clc$true_false_boolean, work_area, result);

    ELSEIF attribute_name = 'EXPONENT_UNDERFLOW' THEN
      clp$make_boolean_value (pmc$exponent_underflow IN default_program_options.conditions_enabled,
            clc$true_false_boolean, work_area, result);

    ELSEIF attribute_name = 'FP_INDEFINITE' THEN
      clp$make_boolean_value (pmc$fp_indefinite IN default_program_options.conditions_enabled,
            clc$true_false_boolean, work_area, result);

    ELSEIF attribute_name = 'FP_LOSS_OF_SIGNIFICANCE' THEN
      clp$make_boolean_value (pmc$fp_significance_loss IN default_program_options.conditions_enabled,
            clc$true_false_boolean, work_area, result);

    ELSEIF attribute_name = 'INVALID_BDP_DATA' THEN
      clp$make_boolean_value (pmc$invalid_bdp_data IN default_program_options.conditions_enabled,
            clc$true_false_boolean, work_area, result);

    IFEND;

  PROCEND pmp$$program;
?? TITLE := 'get_load_map_options', EJECT ??

  PROCEDURE get_load_map_options
    (    parameter: clt$parameter_value;
     VAR map_options: pmt$load_map_options;
     VAR status: ost$status);

    VAR
      map_option: pmc$segment_map .. pmc$entry_point_xref,
      value: ^clt$data_value;

    map_options := $pmt$load_map_options [];
    value := parameter.value;
    IF value^.kind = clc$keyword THEN
      IF value^.keyword_value = 'ALL' THEN
        map_options := map_options + $pmt$load_map_options [pmc$segment_map, pmc$block_map,
              pmc$entry_point_map, pmc$entry_point_xref];
      ELSE {keyword = NONE}
        map_options := map_options + $pmt$load_map_options [pmc$no_load_map];
      IFEND;
    ELSEIF value^.kind = clc$list THEN
      WHILE value <> NIL DO
        IF value^.element_value^.keyword_value = 'SEGMENT' THEN
          map_option := pmc$segment_map;
        ELSEIF value^.element_value^.keyword_value = 'BLOCK' THEN
          map_option := pmc$block_map;
        ELSEIF value^.element_value^.keyword_value = 'ENTRY_POINT' THEN
          map_option := pmc$entry_point_map;
        ELSE { CROSS_REFERENCE
          map_option := pmc$entry_point_xref;
        IFEND;
        IF map_option IN map_options THEN
          osp$set_status_abnormal ('CL', cle$redundancy_in_selections, 'LOAD_MAP_OPTIONS', status);
          RETURN;
        IFEND;
        map_options := map_options + $pmt$load_map_options [map_option];
        value := value^.link;
      WHILEND;
    IFEND;
  PROCEND get_load_map_options;
MODEND pmm$program_execution_commands;
