?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE Object Code Maintenance: Change Program Description' ??
MODULE ocm$change_program_description;

{
{ PURPOSE:
{   To change a program description on an object library.
{

?? NEWTITLE := 'Global Declarations Referenced by This Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc clt$parameter_list
*copyc llt$program_description
*copyc oce$library_generator_errors
*copyc oct$new_library_module_list
*copyc ost$status
?? POP ??
*copyc avp$get_capability
*copyc clp$count_list_elements
*copyc clp$evaluate_parameters
*copyc i#current_sequence_position
*copyc ocp$close_all_open_files
*copyc ocp$initialize_olg_working_heap
*copyc ocp$search_nlm_tree
*copyc ocv$olg_scratch_seq
*copyc ocv$olg_working_heap
*copyc ocv$open_file_list
*copyc osp$set_status_abnormal
*copyc osp$set_status_condition
*copyc pmp$continue_to_cause
*copyc pmp$disestablish_cond_handler
*copyc pmp$establish_condition_handler
*copyc pmp$get_date
*copyc pmp$get_time
?? OLDTITLE ??
?? NEWTITLE := 'ocp$_change_program_description', EJECT ??

  PROCEDURE [XDCL] ocp$_change_program_description
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{  PROCEDURE (ocm$creol_chapd) change_program_description, chapd (
{    name, names, n: list of program_name = $required
{    file, files, f, object_files: any of
{        key
{          $unspecified
{        keyend
{        list of any of
{          file
{          string
{        anyend
{      anyend = $optional
{    library, libraries, l: any of
{        key
{          $unspecified
{        keyend
{        list of any of
{          key
{            osf$task_services_library, osf$current_library
{          keyend
{          file
{          string
{        anyend
{      anyend = $optional
{    module, modules, m: any of
{        key
{          $unspecified
{        keyend
{        list of program_name
{      anyend = $optional
{    starting_procedure, sp: any of
{        key
{          $unspecified
{        keyend
{        program_name
{      anyend = $optional
{    load_map, lm: (BY_NAME) any of
{        key
{          $unspecified
{        keyend
{        file
{        string
{      anyend = $optional
{    load_map_option, load_map_options, lmo: (BY_NAME) any of
{        key
{          $unspecified, all, none
{        keyend
{        list of key
{          (segment, s)
{          (block, b)
{          (entry_point, ep)
{          (cross_reference, cr, xref)
{        keyend
{      anyend = $optional
{    termination_error_level, tel: (BY_NAME) key
{        $unspecified
{        (warning, w)
{        (error, e)
{        (fatal, f)
{      keyend = $optional
{    preset_value, pv: (BY_NAME) key
{        $unspecified
{        (zero, z)
{        (infinity, i)
{        (floating_point_indefinite, fpi)
{        (alternate_ones, ao)
{      keyend = $optional
{    stack_size, ss: (BY_NAME) any of
{        key
{          $unspecified
{        keyend
{        integer 0..osc$max_segment_length
{      anyend = $optional
{    abort_file, af: (BY_NAME) any of
{        key
{          $unspecified
{        keyend
{        file
{        string
{      anyend = $optional
{    debug_input, di: (BY_NAME) any of
{        key
{          $unspecified
{        keyend
{        file
{        string
{      anyend = $optional
{    debug_output, do: (BY_NAME) any of
{        key
{          $unspecified
{        keyend
{        file
{        string
{      anyend = $optional
{    debug_mode, dm: (BY_NAME) any of
{        key
{          $unspecified
{        keyend
{        boolean
{      anyend = $optional
{    availability, a: (BY_NAME) key
{        (normal_usage, a, advertised, nu)
{        (advanced_usage, au)
{        (hidden, h)
{      keyend = $optional
{    scope, s: (BY_NAME) key
{        (xdcl, x)
{        (gate, g)
{        (local, l)
{      keyend = $optional
{    log_option, lo: (BY_NAME) key
{        (automatic, a)
{        (manual, m)
{      keyend = $optional
{    application_identifier, ai: (BY_NAME, ADVANCED) any of
{        key
{          $unspecified
{        keyend
{        name
{      anyend = $optional
{    arithmetic_overflow, ao: (BY_NAME, ADVANCED) any of
{        key
{          $unspecified
{        keyend
{        boolean
{      anyend = $optional
{    arithmetic_loss_of_significance, alos: (BY_NAME, ADVANCED) any of
{        key
{          $unspecified
{        keyend
{        boolean
{      anyend = $optional
{    divide_fault, df: (BY_NAME, ADVANCED) any of
{        key
{          $unspecified
{        keyend
{        boolean
{      anyend = $optional
{    exponent_overflow, eo: (BY_NAME, ADVANCED) any of
{        key
{          $unspecified
{        keyend
{        boolean
{      anyend = $optional
{    exponent_underflow, eu: (BY_NAME, ADVANCED) any of
{        key
{          $unspecified
{        keyend
{        boolean
{      anyend = $optional
{    fp_indefinite, fpi, fi: (BY_NAME, ADVANCED) any of
{        key
{          $unspecified
{        keyend
{        boolean
{      anyend = $optional
{    fp_loss_of_significance, fplos, flos: (BY_NAME, ADVANCED) any of
{        key
{          $unspecified
{        keyend
{        boolean
{      anyend = $optional
{    invalid_bdp_data, ibdpd, ibd: (BY_NAME, ADVANCED) any of
{        key
{          $unspecified
{        keyend
{        boolean
{      anyend = $optional
{    status)

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 62] of clt$pdt_parameter_name,
      parameters: array [1 .. 27] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$list_type_qualifier_v2,
        element_type_spec: record
          header: clt$type_specification_header,
        recend,
      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 .. 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_v2,
          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,
            recend,
            type_size_2: clt$type_specification_size,
            element_type_spec_2: record
              header: clt$type_specification_header,
              qualifier: clt$string_type_qualifier,
            recend,
          recend,
        recend,
      recend,
      type3: 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_v2,
          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 .. 2] of clt$keyword_specification,
            recend,
            type_size_2: clt$type_specification_size,
            element_type_spec_2: record
              header: clt$type_specification_header,
            recend,
            type_size_3: clt$type_specification_size,
            element_type_spec_3: record
              header: clt$type_specification_header,
              qualifier: clt$string_type_qualifier,
            recend,
          recend,
        recend,
      recend,
      type4: 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_v2,
          element_type_spec: record
            header: clt$type_specification_header,
          recend,
        recend,
      recend,
      type5: 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,
      type6: 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,
        type_size_3: clt$type_specification_size,
        element_type_spec_3: record
          header: clt$type_specification_header,
          qualifier: clt$string_type_qualifier,
        recend,
      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 .. 3] 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_v2,
          element_type_spec: record
            header: clt$type_specification_header,
            qualifier: clt$keyword_type_qualifier,
            keyword_specs: array [1 .. 9] of clt$keyword_specification,
          recend,
        recend,
      recend,
      type8: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 7] of clt$keyword_specification,
      recend,
      type9: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 9] of clt$keyword_specification,
      recend,
      type10: 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$integer_type_qualifier,
        recend,
      recend,
      type11: 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,
        type_size_3: clt$type_specification_size,
        element_type_spec_3: record
          header: clt$type_specification_header,
          qualifier: clt$string_type_qualifier,
        recend,
      recend,
      type12: 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,
        type_size_3: clt$type_specification_size,
        element_type_spec_3: record
          header: clt$type_specification_header,
          qualifier: clt$string_type_qualifier,
        recend,
      recend,
      type13: 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,
        type_size_3: clt$type_specification_size,
        element_type_spec_3: record
          header: clt$type_specification_header,
          qualifier: clt$string_type_qualifier,
        recend,
      recend,
      type14: 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,
      type15: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 8] of clt$keyword_specification,
      recend,
      type16: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 6] of clt$keyword_specification,
      recend,
      type17: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 4] of clt$keyword_specification,
      recend,
      type18: 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$name_type_qualifier,
        recend,
      recend,
      type19: 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,
      type20: 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,
      type21: 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,
      type22: 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,
      type23: 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,
      type24: 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,
      type25: 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,
      type26: 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,
      type27: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [92, 3, 20, 12, 7, 7, 728],
    clc$command, 62, 27, 1, 9, 0, 0, 27, 'OCM$CREOL_CHAPD'], [
    ['A                              ',clc$abbreviation_entry, 15],
    ['ABORT_FILE                     ',clc$nominal_entry, 11],
    ['AF                             ',clc$abbreviation_entry, 11],
    ['AI                             ',clc$abbreviation_entry, 18],
    ['ALOS                           ',clc$abbreviation_entry, 20],
    ['AO                             ',clc$abbreviation_entry, 19],
    ['APPLICATION_IDENTIFIER         ',clc$nominal_entry, 18],
    ['ARITHMETIC_LOSS_OF_SIGNIFICANCE',clc$nominal_entry, 20],
    ['ARITHMETIC_OVERFLOW            ',clc$nominal_entry, 19],
    ['AVAILABILITY                   ',clc$nominal_entry, 15],
    ['DEBUG_INPUT                    ',clc$nominal_entry, 12],
    ['DEBUG_MODE                     ',clc$nominal_entry, 14],
    ['DEBUG_OUTPUT                   ',clc$nominal_entry, 13],
    ['DF                             ',clc$abbreviation_entry, 21],
    ['DI                             ',clc$abbreviation_entry, 12],
    ['DIVIDE_FAULT                   ',clc$nominal_entry, 21],
    ['DM                             ',clc$abbreviation_entry, 14],
    ['DO                             ',clc$abbreviation_entry, 13],
    ['EO                             ',clc$abbreviation_entry, 22],
    ['EU                             ',clc$abbreviation_entry, 23],
    ['EXPONENT_OVERFLOW              ',clc$nominal_entry, 22],
    ['EXPONENT_UNDERFLOW             ',clc$nominal_entry, 23],
    ['F                              ',clc$alias_entry, 2],
    ['FI                             ',clc$abbreviation_entry, 24],
    ['FILE                           ',clc$nominal_entry, 2],
    ['FILES                          ',clc$alias_entry, 2],
    ['FLOS                           ',clc$abbreviation_entry, 25],
    ['FPI                            ',clc$alias_entry, 24],
    ['FPLOS                          ',clc$alias_entry, 25],
    ['FP_INDEFINITE                  ',clc$nominal_entry, 24],
    ['FP_LOSS_OF_SIGNIFICANCE        ',clc$nominal_entry, 25],
    ['IBD                            ',clc$abbreviation_entry, 26],
    ['IBDPD                          ',clc$alias_entry, 26],
    ['INVALID_BDP_DATA               ',clc$nominal_entry, 26],
    ['L                              ',clc$abbreviation_entry, 3],
    ['LIBRARIES                      ',clc$alias_entry, 3],
    ['LIBRARY                        ',clc$nominal_entry, 3],
    ['LM                             ',clc$abbreviation_entry, 6],
    ['LMO                            ',clc$abbreviation_entry, 7],
    ['LO                             ',clc$abbreviation_entry, 17],
    ['LOAD_MAP                       ',clc$nominal_entry, 6],
    ['LOAD_MAP_OPTION                ',clc$nominal_entry, 7],
    ['LOAD_MAP_OPTIONS               ',clc$alias_entry, 7],
    ['LOG_OPTION                     ',clc$nominal_entry, 17],
    ['M                              ',clc$abbreviation_entry, 4],
    ['MODULE                         ',clc$nominal_entry, 4],
    ['MODULES                        ',clc$alias_entry, 4],
    ['N                              ',clc$abbreviation_entry, 1],
    ['NAME                           ',clc$nominal_entry, 1],
    ['NAMES                          ',clc$alias_entry, 1],
    ['OBJECT_FILES                   ',clc$abbreviation_entry, 2],
    ['PRESET_VALUE                   ',clc$nominal_entry, 9],
    ['PV                             ',clc$abbreviation_entry, 9],
    ['S                              ',clc$abbreviation_entry, 16],
    ['SCOPE                          ',clc$nominal_entry, 16],
    ['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, 27],
    ['TEL                            ',clc$abbreviation_entry, 8],
    ['TERMINATION_ERROR_LEVEL        ',clc$nominal_entry, 8]],
    [
{ PARAMETER 1
    [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, 19, clc$required_parameter, 0, 0],
{ PARAMETER 2
    [25, 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, 111, clc$optional_parameter, 0, 0],
{ PARAMETER 3
    [37, 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, 196, clc$optional_parameter, 0, 0],
{ PARAMETER 4
    [46, 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 5
    [59, 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, 67, clc$optional_parameter, 0, 0],
{ PARAMETER 6
    [41, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 79, clc$optional_parameter, 0, 0],
{ PARAMETER 7
    [42, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 494, clc$optional_parameter, 0, 0],
{ PARAMETER 8
    [62, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 266, clc$optional_parameter, 0, 0],
{ PARAMETER 9
    [52, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 340, clc$optional_parameter, 0, 0],
{ PARAMETER 10
    [58, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 84, clc$optional_parameter, 0, 0],
{ PARAMETER 11
    [2, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 79, clc$optional_parameter, 0, 0],
{ PARAMETER 12
    [11, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 79, clc$optional_parameter, 0, 0],
{ PARAMETER 13
    [13, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 79, clc$optional_parameter, 0, 0],
{ PARAMETER 14
    [12, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 67, clc$optional_parameter, 0, 0],
{ PARAMETER 15
    [10, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 303, clc$optional_parameter, 0, 0],
{ PARAMETER 16
    [55, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 229, clc$optional_parameter, 0, 0],
{ PARAMETER 17
    [44, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 155, clc$optional_parameter, 0, 0],
{ PARAMETER 18
    [7, clc$advanced_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 69, clc$optional_parameter, 0, 0],
{ PARAMETER 19
    [9, clc$advanced_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 67, clc$optional_parameter, 0, 0],
{ PARAMETER 20
    [8, clc$advanced_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 67, clc$optional_parameter, 0, 0],
{ PARAMETER 21
    [16, clc$advanced_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 67, clc$optional_parameter, 0, 0],
{ PARAMETER 22
    [21, clc$advanced_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 67, clc$optional_parameter, 0, 0],
{ PARAMETER 23
    [22, clc$advanced_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 67, clc$optional_parameter, 0, 0],
{ PARAMETER 24
    [30, clc$advanced_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 67, clc$optional_parameter, 0, 0],
{ PARAMETER 25
    [31, clc$advanced_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 67, clc$optional_parameter, 0, 0],
{ PARAMETER 26
    [34, clc$advanced_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 67, clc$optional_parameter, 0, 0],
{ PARAMETER 27
    [60, 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, 0, FALSE, FALSE],
      [[1, 0, clc$program_name_type]]
    ],
{ PARAMETER 2
    [[1, 0, clc$union_type], [[clc$keyword_type,
    clc$list_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['$UNSPECIFIED                   ', clc$nominal_entry,
  clc$normal_usage_entry, 1]]
      ],
    47, [[1, 0, clc$list_type], [31, 1, clc$max_list_size, 0, FALSE, FALSE],
        [[1, 0, clc$union_type], [[clc$file_type,
        clc$string_type],
        TRUE, 2],
        3, [[1, 0, clc$file_type]],
        8, [[1, 0, clc$string_type], [0, clc$max_string_size, FALSE]]
        ]
      ]
    ],
{ PARAMETER 3
    [[1, 0, clc$union_type], [[clc$keyword_type,
    clc$list_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['$UNSPECIFIED                   ', clc$nominal_entry,
  clc$normal_usage_entry, 1]]
      ],
    132, [[1, 0, clc$list_type], [116, 1, clc$max_list_size, 0, FALSE, FALSE],
        [[1, 0, clc$union_type], [[clc$file_type,
        clc$keyword_type, clc$string_type],
        FALSE, 3],
        81, [[1, 0, clc$keyword_type], [2], [
          ['OSF$CURRENT_LIBRARY            ', clc$nominal_entry,
  clc$normal_usage_entry, 2],
          ['OSF$TASK_SERVICES_LIBRARY      ', clc$nominal_entry,
  clc$normal_usage_entry, 1]]
          ],
        3, [[1, 0, clc$file_type]],
        8, [[1, 0, clc$string_type], [0, clc$max_string_size, FALSE]]
        ]
      ]
    ],
{ PARAMETER 4
    [[1, 0, clc$union_type], [[clc$keyword_type,
    clc$list_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['$UNSPECIFIED                   ', clc$nominal_entry,
  clc$normal_usage_entry, 1]]
      ],
    19, [[1, 0, clc$list_type], [3, 1, clc$max_list_size, 0, FALSE, FALSE],
        [[1, 0, clc$program_name_type]]
      ]
    ],
{ PARAMETER 5
    [[1, 0, clc$union_type], [[clc$keyword_type,
    clc$program_name_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['$UNSPECIFIED                   ', clc$nominal_entry,
  clc$normal_usage_entry, 1]]
      ],
    3, [[1, 0, clc$program_name_type]]
    ],
{ PARAMETER 6
    [[1, 0, clc$union_type], [[clc$file_type, clc$keyword_type,
    clc$string_type],
    FALSE, 3],
    44, [[1, 0, clc$keyword_type], [1], [
      ['$UNSPECIFIED                   ', clc$nominal_entry,
  clc$normal_usage_entry, 1]]
      ],
    3, [[1, 0, clc$file_type]],
    8, [[1, 0, clc$string_type], [0, clc$max_string_size, FALSE]]
    ],
{ PARAMETER 7
    [[1, 0, clc$union_type], [[clc$keyword_type,
    clc$list_type],
    FALSE, 2],
    118, [[1, 0, clc$keyword_type], [3], [
      ['$UNSPECIFIED                   ', clc$nominal_entry,
  clc$normal_usage_entry, 1],
      ['ALL                            ', clc$nominal_entry,
  clc$normal_usage_entry, 2],
      ['NONE                           ', clc$nominal_entry,
  clc$normal_usage_entry, 3]]
      ],
    356, [[1, 0, clc$list_type], [340, 1, clc$max_list_size, 0, FALSE, FALSE],
        [[1, 0, clc$keyword_type], [9], [
        ['B                              ', clc$abbreviation_entry,
  clc$normal_usage_entry, 2],
        ['BLOCK                          ', clc$nominal_entry,
  clc$normal_usage_entry, 2],
        ['CR                             ', clc$alias_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],
        ['XREF                           ', clc$abbreviation_entry,
  clc$normal_usage_entry, 4]]
        ]
      ]
    ],
{ PARAMETER 8
    [[1, 0, clc$keyword_type], [7], [
    ['$UNSPECIFIED                   ', clc$nominal_entry,
  clc$normal_usage_entry, 1],
    ['E                              ', clc$abbreviation_entry,
  clc$normal_usage_entry, 3],
    ['ERROR                          ', clc$nominal_entry,
  clc$normal_usage_entry, 3],
    ['F                              ', clc$abbreviation_entry,
  clc$normal_usage_entry, 4],
    ['FATAL                          ', clc$nominal_entry,
  clc$normal_usage_entry, 4],
    ['W                              ', clc$abbreviation_entry,
  clc$normal_usage_entry, 2],
    ['WARNING                        ', clc$nominal_entry,
  clc$normal_usage_entry, 2]]
    ],
{ PARAMETER 9
    [[1, 0, clc$keyword_type], [9], [
    ['$UNSPECIFIED                   ', clc$nominal_entry,
  clc$normal_usage_entry, 1],
    ['ALTERNATE_ONES                 ', clc$nominal_entry,
  clc$normal_usage_entry, 5],
    ['AO                             ', clc$abbreviation_entry,
  clc$normal_usage_entry, 5],
    ['FLOATING_POINT_INDEFINITE      ', clc$nominal_entry,
  clc$normal_usage_entry, 4],
    ['FPI                            ', clc$abbreviation_entry,
  clc$normal_usage_entry, 4],
    ['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, 2],
    ['ZERO                           ', clc$nominal_entry,
  clc$normal_usage_entry, 2]]
    ],
{ PARAMETER 10
    [[1, 0, clc$union_type], [[clc$integer_type,
    clc$keyword_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['$UNSPECIFIED                   ', clc$nominal_entry,
  clc$normal_usage_entry, 1]]
      ],
    20, [[1, 0, clc$integer_type], [0, osc$max_segment_length, 10]]
    ],
{ PARAMETER 11
    [[1, 0, clc$union_type], [[clc$file_type, clc$keyword_type,
    clc$string_type],
    FALSE, 3],
    44, [[1, 0, clc$keyword_type], [1], [
      ['$UNSPECIFIED                   ', clc$nominal_entry,
  clc$normal_usage_entry, 1]]
      ],
    3, [[1, 0, clc$file_type]],
    8, [[1, 0, clc$string_type], [0, clc$max_string_size, FALSE]]
    ],
{ PARAMETER 12
    [[1, 0, clc$union_type], [[clc$file_type, clc$keyword_type,
    clc$string_type],
    FALSE, 3],
    44, [[1, 0, clc$keyword_type], [1], [
      ['$UNSPECIFIED                   ', clc$nominal_entry,
  clc$normal_usage_entry, 1]]
      ],
    3, [[1, 0, clc$file_type]],
    8, [[1, 0, clc$string_type], [0, clc$max_string_size, FALSE]]
    ],
{ PARAMETER 13
    [[1, 0, clc$union_type], [[clc$file_type, clc$keyword_type,
    clc$string_type],
    FALSE, 3],
    44, [[1, 0, clc$keyword_type], [1], [
      ['$UNSPECIFIED                   ', clc$nominal_entry,
  clc$normal_usage_entry, 1]]
      ],
    3, [[1, 0, clc$file_type]],
    8, [[1, 0, clc$string_type], [0, clc$max_string_size, FALSE]]
    ],
{ PARAMETER 14
    [[1, 0, clc$union_type], [[clc$boolean_type,
    clc$keyword_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['$UNSPECIFIED                   ', clc$nominal_entry,
  clc$normal_usage_entry, 1]]
      ],
    3, [[1, 0, clc$boolean_type]]
    ],
{ PARAMETER 15
    [[1, 0, clc$keyword_type], [8], [
    ['A                              ', clc$alias_entry,
  clc$normal_usage_entry, 1],
    ['ADVANCED_USAGE                 ', clc$nominal_entry,
  clc$normal_usage_entry, 2],
    ['ADVERTISED                     ', clc$alias_entry,
  clc$normal_usage_entry, 1],
    ['AU                             ', clc$abbreviation_entry,
  clc$normal_usage_entry, 2],
    ['H                              ', clc$abbreviation_entry,
  clc$normal_usage_entry, 3],
    ['HIDDEN                         ', clc$nominal_entry,
  clc$normal_usage_entry, 3],
    ['NORMAL_USAGE                   ', clc$nominal_entry,
  clc$normal_usage_entry, 1],
    ['NU                             ', clc$abbreviation_entry,
  clc$normal_usage_entry, 1]]
    ],
{ PARAMETER 16
    [[1, 0, clc$keyword_type], [6], [
    ['G                              ', clc$abbreviation_entry,
  clc$normal_usage_entry, 2],
    ['GATE                           ', clc$nominal_entry,
  clc$normal_usage_entry, 2],
    ['L                              ', clc$abbreviation_entry,
  clc$normal_usage_entry, 3],
    ['LOCAL                          ', clc$nominal_entry,
  clc$normal_usage_entry, 3],
    ['X                              ', clc$abbreviation_entry,
  clc$normal_usage_entry, 1],
    ['XDCL                           ', clc$nominal_entry,
  clc$normal_usage_entry, 1]]
    ],
{ PARAMETER 17
    [[1, 0, clc$keyword_type], [4], [
    ['A                              ', clc$abbreviation_entry,
  clc$normal_usage_entry, 1],
    ['AUTOMATIC                      ', clc$nominal_entry,
  clc$normal_usage_entry, 1],
    ['M                              ', clc$abbreviation_entry,
  clc$normal_usage_entry, 2],
    ['MANUAL                         ', clc$nominal_entry,
  clc$normal_usage_entry, 2]]
    ],
{ PARAMETER 18
    [[1, 0, clc$union_type], [[clc$keyword_type,
    clc$name_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['$UNSPECIFIED                   ', clc$nominal_entry,
  clc$normal_usage_entry, 1]]
      ],
    5, [[1, 0, clc$name_type], [1, osc$max_name_size]]
    ],
{ PARAMETER 19
    [[1, 0, clc$union_type], [[clc$boolean_type,
    clc$keyword_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['$UNSPECIFIED                   ', clc$nominal_entry,
  clc$normal_usage_entry, 1]]
      ],
    3, [[1, 0, clc$boolean_type]]
    ],
{ PARAMETER 20
    [[1, 0, clc$union_type], [[clc$boolean_type,
    clc$keyword_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['$UNSPECIFIED                   ', clc$nominal_entry,
  clc$normal_usage_entry, 1]]
      ],
    3, [[1, 0, clc$boolean_type]]
    ],
{ PARAMETER 21
    [[1, 0, clc$union_type], [[clc$boolean_type,
    clc$keyword_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['$UNSPECIFIED                   ', clc$nominal_entry,
  clc$normal_usage_entry, 1]]
      ],
    3, [[1, 0, clc$boolean_type]]
    ],
{ PARAMETER 22
    [[1, 0, clc$union_type], [[clc$boolean_type,
    clc$keyword_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['$UNSPECIFIED                   ', clc$nominal_entry,
  clc$normal_usage_entry, 1]]
      ],
    3, [[1, 0, clc$boolean_type]]
    ],
{ PARAMETER 23
    [[1, 0, clc$union_type], [[clc$boolean_type,
    clc$keyword_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['$UNSPECIFIED                   ', clc$nominal_entry,
  clc$normal_usage_entry, 1]]
      ],
    3, [[1, 0, clc$boolean_type]]
    ],
{ PARAMETER 24
    [[1, 0, clc$union_type], [[clc$boolean_type,
    clc$keyword_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['$UNSPECIFIED                   ', clc$nominal_entry,
  clc$normal_usage_entry, 1]]
      ],
    3, [[1, 0, clc$boolean_type]]
    ],
{ PARAMETER 25
    [[1, 0, clc$union_type], [[clc$boolean_type,
    clc$keyword_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['$UNSPECIFIED                   ', clc$nominal_entry,
  clc$normal_usage_entry, 1]]
      ],
    3, [[1, 0, clc$boolean_type]]
    ],
{ PARAMETER 26
    [[1, 0, clc$union_type], [[clc$boolean_type,
    clc$keyword_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['$UNSPECIFIED                   ', clc$nominal_entry,
  clc$normal_usage_entry, 1]]
      ],
    3, [[1, 0, clc$boolean_type]]
    ],
{ PARAMETER 27
    [[1, 0, clc$status_type]]];

?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$name = 1,
      p$file = 2,
      p$library = 3,
      p$module = 4,
      p$starting_procedure = 5,
      p$load_map = 6,
      p$load_map_option = 7,
      p$termination_error_level = 8,
      p$preset_value = 9,
      p$stack_size = 10,
      p$abort_file = 11,
      p$debug_input = 12,
      p$debug_output = 13,
      p$debug_mode = 14,
      p$availability = 15,
      p$scope = 16,
      p$log_option = 17,
      p$application_identifier = 18,
      p$arithmetic_overflow = 19,
      p$arithmetic_loss_of_significan = 20 {ARITHMETIC_LOSS_OF_SIGNIFICANCE} ,
      p$divide_fault = 21,
      p$exponent_overflow = 22,
      p$exponent_underflow = 23,
      p$fp_indefinite = 24,
      p$fp_loss_of_significance = 25,
      p$invalid_bdp_data = 26,
      p$status = 27;

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

    CONST
      unspecified = '$UNSPECIFIED';

    VAR
      application_administrator: boolean,
      date: ost$date,
      i: clt$list_size,
      ignore_status: ost$status,
      member: ^SEQ ( * ),
      member_size: ost$segment_length,
      module_description: ^oct$module_description,
      module_does_exist: boolean,
      name: pmt$program_name,
      name_node: ^clt$data_value,
      new_alias_list: ^pmt$module_list,
      new_applic_program_header: ^llt$application_member_header,
      new_application_identifier: ^llt$application_identifier,
      new_enable_inhibit_conditions: ^pmt$enable_inhibit_conditions,
      new_module_list: ^pmt$module_list,
      new_object_file_list: ^llt$object_file_list,
      new_object_library_list: ^llt$object_library_list,
      new_program_attributes: ^llt$program_attributes,
      new_program_description_header: ^llt$library_member_header,
      nlm: ^oct$new_library_module_list,
      node: ^clt$data_value,
      number_of_libraries: clt$list_size,
      number_of_modules: clt$list_size,
      number_of_object_files: clt$list_size,
      old_alias_list: ^pmt$module_list,
      old_application_identifier: ^llt$application_identifier,
      old_enable_inhibit_conditions: ^pmt$enable_inhibit_conditions,
      old_member: ^SEQ ( * ),
      old_module_list: ^pmt$module_list,
      old_number_of_libraries: clt$list_size,
      old_number_of_modules: clt$list_size,
      old_number_of_object_files: clt$list_size,
      old_object_file_list: ^llt$object_file_list,
      old_object_library_list: ^llt$object_library_list,
      old_program_attributes: ^llt$program_attributes,
      old_program_description_header: ^llt$library_member_header,
      old_seq: ^SEQ ( * ),
      sequence: ^SEQ ( * ),
      size: ost$segment_length,
      temp_enable_inhibit_conditions: pmt$enable_inhibit_conditions,
      time: ost$time;

    VAR
      established_conditions: pmt$condition,
      established_descriptor: pmt$established_handler;

?? NEWTITLE := 'condition_handler', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to handle the terminate break and
{   block exit conditions.

    PROCEDURE condition_handler
      (    condition: pmt$condition;
           condition_descriptor: ^pmt$condition_information;
           stack_frame_save_area_p: ^ost$stack_frame_save_area;
       VAR handler_status: ost$status);


      IF (condition.selector = ifc$interactive_condition) AND
            (condition.interactive_condition = ifc$terminate_break) THEN

{ Ignore the condition.

        RETURN;
      ELSEIF condition.selector = pmc$block_exit_processing THEN
        ocp$close_all_open_files (ocv$open_file_list);
        ocp$initialize_olg_working_heap;
        RESET ocv$olg_scratch_seq;
      ELSE
        pmp$continue_to_cause (pmc$execute_standard_procedure, handler_status);
      IFEND;

    PROCEND condition_handler;
?? OLDTITLE ??
?? NEWTITLE := 'change_system_condition_param', EJECT ??

    PROCEDURE [INLINE] change_system_condition_param
      (    parameter_number: clt$parameter_number;
           system_condition: pmt$system_condition);


      IF pvt [parameter_number].specified THEN
        IF pvt [parameter_number].value^.kind = clc$keyword { keyword = unspecified} THEN
          temp_enable_inhibit_conditions.enable_system_conditions :=
                temp_enable_inhibit_conditions.enable_system_conditions -
                $pmt$system_conditions [system_condition];
          temp_enable_inhibit_conditions.inhibit_system_conditions :=
                temp_enable_inhibit_conditions.inhibit_system_conditions -
                $pmt$system_conditions [system_condition];
        ELSE {clc$boolean}
          IF pvt [parameter_number].value^.boolean_value.value THEN
            temp_enable_inhibit_conditions.enable_system_conditions :=
                  temp_enable_inhibit_conditions.enable_system_conditions +
                  $pmt$system_conditions [system_condition];
            temp_enable_inhibit_conditions.inhibit_system_conditions :=
                  temp_enable_inhibit_conditions.inhibit_system_conditions -
                  $pmt$system_conditions [system_condition];
          ELSE
            temp_enable_inhibit_conditions.enable_system_conditions :=
                  temp_enable_inhibit_conditions.enable_system_conditions -
                  $pmt$system_conditions [system_condition];
            temp_enable_inhibit_conditions.inhibit_system_conditions :=
                  temp_enable_inhibit_conditions.inhibit_system_conditions +
                  $pmt$system_conditions [system_condition];
          IFEND;
        IFEND;
      IFEND;

    PROCEND change_system_condition_param;
?? OLDTITLE, EJECT ??

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

    IF pvt [p$application_identifier].specified THEN
      avp$get_capability (avc$application_administration, avc$user, application_administrator, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      IF NOT application_administrator THEN
        osp$set_status_condition (oce$not_application_administrtr, status);
        RETURN;
      IFEND;
    IFEND;

    established_conditions.selector := pmc$condition_combination;
    established_conditions.combination := $pmt$condition_combination
          [ifc$interactive_condition, pmc$block_exit_processing];
    pmp$establish_condition_handler (established_conditions, ^condition_handler, ^established_descriptor,
          status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

  /protect/
    BEGIN

      name_node := pvt [p$name].value;
      WHILE (name_node <> NIL) AND (name_node^.element_value <> NIL) DO
        name := name_node^.element_value^.program_name_value;
        ocp$search_nlm_tree (name, nlm, module_does_exist);
        IF NOT module_does_exist THEN
          osp$set_status_abnormal ('OC', oce$w_module_not_found, name, status);
          EXIT /protect/;
        IFEND;
        CASE nlm^.description^.kind OF
        = occ$program_description =
          old_program_description_header := nlm^.description^.program_description_header;
          old_application_identifier := NIL;
        = occ$applic_program_description =
          old_program_description_header := ^nlm^.description^.applic_program_description_hdr^.
                library_member_header;
          old_application_identifier := ^nlm^.description^.applic_program_description_hdr^.
                application_identifier;
        ELSE
          osp$set_status_abnormal ('OC', oce$e_module_is_not_a_prog_desc, name, status);
          EXIT /protect/;
        CASEND;
        old_number_of_object_files := 0;
        old_number_of_modules := 0;
        old_number_of_libraries := 0;

        old_seq := nlm^.description^.file;
        RESET ocv$olg_scratch_seq;
        NEXT new_program_description_header IN ocv$olg_scratch_seq;
        IF new_program_description_header = NIL THEN
          osp$set_status_condition (oce$e_internal_olg_seg_overflow, status);
          RETURN;
        IFEND;

        new_program_description_header^ := old_program_description_header^;

{   Since an APPLICATION PROGRAM DESCRIPTION is a record of:
{                llt$library_member_header,
{                llt$application_identifier,
{ processing of the APPLICATION_IDENTIFIER parameter must be done first after the
{ program description is set up so that the application identifier (llt$application_identifier)
{ immediately follows the program description (llt$library_member_header) in OCV$OLG_SCRATCH_SEQ.

        new_application_identifier := NIL;
        IF pvt [p$application_identifier].specified THEN
          IF pvt [p$application_identifier].value^.kind = clc$keyword { keyword = unspecified} THEN
            new_program_description_header^.kind := llc$program_description;
          ELSE {clc$name}
            NEXT new_application_identifier IN ocv$olg_scratch_seq;
            IF new_application_identifier = NIL THEN
              osp$set_status_condition (oce$e_internal_olg_seg_overflow, status);
              RETURN;
            IFEND;
            new_application_identifier^.name := pvt [p$application_identifier].value^.name_value;
            new_program_description_header^.kind := llc$applic_program_description;
          IFEND;
        ELSEIF old_application_identifier <> NIL THEN
          NEXT new_application_identifier IN ocv$olg_scratch_seq;
          IF new_application_identifier = NIL THEN
            osp$set_status_condition (oce$e_internal_olg_seg_overflow, status);
            RETURN;
          IFEND;
          new_application_identifier^.name := old_application_identifier^.name;
        IFEND;

        IF new_program_description_header^.number_of_aliases <> 0 THEN
          old_alias_list := #PTR (old_program_description_header^.aliases, old_seq^);
          NEXT new_alias_list: [1 .. new_program_description_header^.number_of_aliases] IN
                ocv$olg_scratch_seq;
          IF new_alias_list = NIL THEN
            osp$set_status_abnormal ('OC', oce$e_premature_eof_in_module, name, status);
            EXIT /protect/;
          IFEND;
          new_alias_list^ := old_alias_list^;
        IFEND;

        old_member := #PTR (old_program_description_header^.member, old_seq^);
        RESET old_member;
        NEXT old_program_attributes IN old_member;
        IF old_program_attributes = NIL THEN
          osp$set_status_condition (oce$e_internal_olg_seg_overflow, status);
          RETURN;
        IFEND;
        NEXT new_program_attributes IN ocv$olg_scratch_seq;
        IF new_program_attributes = NIL THEN
          osp$set_status_condition (oce$e_internal_olg_seg_overflow, status);
          RETURN;
        IFEND;
        new_program_attributes^ := old_program_attributes^;

        IF (pmc$object_file_list_specified IN old_program_attributes^.contents) AND
              (old_program_attributes^.number_of_object_files > 0) THEN
          old_number_of_object_files := old_program_attributes^.number_of_object_files;
          NEXT old_object_file_list: [1 .. old_program_attributes^.number_of_object_files] IN old_member;
          IF old_object_file_list = NIL THEN
            osp$set_status_condition (oce$e_internal_olg_seg_overflow, status);
            RETURN;
          IFEND;
        IFEND;
        IF pvt [p$file].specified THEN
          IF pvt [p$file].value^.kind = clc$keyword { keyword = unspecified} THEN
            new_program_attributes^.contents := new_program_attributes^.contents -
                  $pmt$prog_description_contents [pmc$object_file_list_specified];
            new_program_attributes^.number_of_object_files := 0;
          ELSE {clc$list of clc$file or clc$string}
            number_of_object_files := clp$count_list_elements (pvt [p$file].value);
            new_program_attributes^.contents := new_program_attributes^.contents +
                  $pmt$prog_description_contents [pmc$object_file_list_specified];
            new_program_attributes^.number_of_object_files := number_of_object_files;
            NEXT new_object_file_list: [1 .. number_of_object_files] IN ocv$olg_scratch_seq;
            IF new_object_file_list = NIL THEN
              osp$set_status_condition (oce$e_internal_olg_seg_overflow, status);
              RETURN;
            IFEND;
            node := pvt [p$file].value;
            FOR i := 1 TO number_of_object_files DO
              IF node^.element_value^.kind = clc$file THEN
                new_object_file_list^ [i] := node^.element_value^.file_value^;
              ELSE {clc$string}
                new_object_file_list^ [i] := node^.element_value^.string_value^;
              IFEND;
              node := node^.link;
            FOREND;
          IFEND;
        ELSEIF old_number_of_object_files > 0 THEN
          NEXT new_object_file_list: [1 .. old_number_of_object_files] IN ocv$olg_scratch_seq;
          IF new_object_file_list = NIL THEN
            osp$set_status_condition (oce$e_internal_olg_seg_overflow, status);
            RETURN;
          IFEND;
          new_object_file_list^ := old_object_file_list^;
        IFEND;

        IF (pmc$module_list_specified IN old_program_attributes^.contents) AND
              (old_program_attributes^.number_of_modules > 0) THEN
          old_number_of_modules := old_program_attributes^.number_of_modules;
          NEXT old_module_list: [1 .. old_program_attributes^.number_of_modules] IN old_member;
          IF old_module_list = NIL THEN
            osp$set_status_condition (oce$e_internal_olg_seg_overflow, status);
            RETURN;
          IFEND;
        IFEND;
        IF pvt [p$module].specified THEN
          IF pvt [p$module].value^.kind = clc$keyword { keyword = unspecified} THEN
            new_program_attributes^.contents := new_program_attributes^.contents -
                  $pmt$prog_description_contents [pmc$module_list_specified];
            new_program_attributes^.number_of_modules := 0;
          ELSE {clc$list of clc$program_name}
            number_of_modules := clp$count_list_elements (pvt [p$module].value);
            new_program_attributes^.contents := new_program_attributes^.contents +
                  $pmt$prog_description_contents [pmc$module_list_specified];
            new_program_attributes^.number_of_modules := number_of_modules;
            NEXT new_module_list: [1 .. number_of_modules] IN ocv$olg_scratch_seq;
            IF new_module_list = NIL THEN
              osp$set_status_condition (oce$e_internal_olg_seg_overflow, status);
              RETURN;
            IFEND;
            node := pvt [p$module].value;
            FOR i := 1 TO number_of_modules DO
              new_module_list^ [i] := node^.element_value^.program_name_value;
              node := node^.link;
            FOREND;
          IFEND;
        ELSEIF old_number_of_modules > 0 THEN
          NEXT new_module_list: [1 .. old_number_of_modules] IN ocv$olg_scratch_seq;
          IF new_module_list = NIL THEN
            osp$set_status_condition (oce$e_internal_olg_seg_overflow, status);
            RETURN;
          IFEND;
          new_module_list^ := old_module_list^;
        IFEND;

        IF (pmc$library_list_specified IN old_program_attributes^.contents) AND
              (old_program_attributes^.number_of_libraries > 0) THEN
          old_number_of_libraries := old_program_attributes^.number_of_libraries;
          NEXT old_object_library_list: [1 .. old_program_attributes^.number_of_libraries] IN old_member;
          IF old_object_library_list = NIL THEN
            osp$set_status_condition (oce$e_internal_olg_seg_overflow, status);
            RETURN;
          IFEND;
        IFEND;
        IF pvt [p$library].specified THEN
          IF pvt [p$library].value^.kind = clc$keyword { keyword = unspecified} THEN
            new_program_attributes^.contents := new_program_attributes^.contents -
                  $pmt$prog_description_contents [pmc$library_list_specified];
            new_program_attributes^.number_of_libraries := 0;
          ELSE {clc$list of clc$keyword or clc$file or clc$string}
            number_of_libraries := clp$count_list_elements (pvt [p$library].value);
            new_program_attributes^.contents := new_program_attributes^.contents +
                  $pmt$prog_description_contents [pmc$library_list_specified];
            new_program_attributes^.number_of_libraries := number_of_libraries;
            NEXT new_object_library_list: [1 .. number_of_libraries] IN ocv$olg_scratch_seq;
            IF new_object_library_list = NIL THEN
              osp$set_status_condition (oce$e_internal_olg_seg_overflow, status);
              RETURN;
            IFEND;
            node := pvt [p$library].value;
            FOR i := 1 TO number_of_libraries DO
              CASE node^.element_value^.kind OF
              = clc$keyword =
                new_object_library_list^ [i] := node^.element_value^.keyword_value;
              = clc$file =
                new_object_library_list^ [i] := node^.element_value^.file_value^;
              ELSE {clc$string}
                new_object_library_list^ [i] := node^.element_value^.string_value^;
              CASEND;
              node := node^.link;
            FOREND;
          IFEND;
        ELSEIF old_number_of_libraries > 0 THEN
          NEXT new_object_library_list: [1 .. old_number_of_libraries] IN ocv$olg_scratch_seq;
          IF new_object_library_list = NIL THEN
            osp$set_status_condition (oce$e_internal_olg_seg_overflow, status);
            RETURN;
          IFEND;
          new_object_library_list^ := old_object_library_list^;
        IFEND;

        IF pmc$condition_specified IN old_program_attributes^.contents THEN
          NEXT old_enable_inhibit_conditions IN old_member;
          IF old_enable_inhibit_conditions = NIL THEN
            osp$set_status_condition (oce$e_internal_olg_seg_overflow, status);
            RETURN;
          IFEND;
          temp_enable_inhibit_conditions := old_enable_inhibit_conditions^;
        ELSE
          temp_enable_inhibit_conditions.enable_system_conditions := $pmt$system_conditions [];
          temp_enable_inhibit_conditions.inhibit_system_conditions := $pmt$system_conditions [];
        IFEND;
        change_system_condition_param (p$arithmetic_overflow, pmc$arithmetic_overflow);
        change_system_condition_param (p$arithmetic_loss_of_significan, pmc$arithmetic_significance);
        change_system_condition_param (p$divide_fault, pmc$divide_fault);
        change_system_condition_param (p$exponent_overflow, pmc$exponent_overflow);
        change_system_condition_param (p$exponent_underflow, pmc$exponent_underflow);
        change_system_condition_param (p$fp_indefinite, pmc$fp_indefinite);
        change_system_condition_param (p$fp_loss_of_significance, pmc$fp_significance_loss);
        change_system_condition_param (p$invalid_bdp_data, pmc$invalid_bdp_data);
        IF (temp_enable_inhibit_conditions.enable_system_conditions = $pmt$system_conditions []) AND
              (temp_enable_inhibit_conditions.inhibit_system_conditions = $pmt$system_conditions []) THEN
          new_program_attributes^.contents := new_program_attributes^.contents -
                $pmt$prog_description_contents [pmc$condition_specified];
        ELSE
          new_program_attributes^.contents := new_program_attributes^.contents +
                $pmt$prog_description_contents [pmc$condition_specified];
          NEXT new_enable_inhibit_conditions IN ocv$olg_scratch_seq;
          IF new_enable_inhibit_conditions = NIL THEN
            osp$set_status_condition (oce$e_internal_olg_seg_overflow, status);
            RETURN;
          IFEND;
          new_enable_inhibit_conditions^ := temp_enable_inhibit_conditions;
        IFEND;

        IF pvt [p$starting_procedure].specified THEN
          IF pvt [p$starting_procedure].value^.kind = clc$keyword { keyword = unspecified} THEN
            new_program_attributes^.contents := new_program_attributes^.contents -
                  $pmt$prog_description_contents [pmc$starting_proc_specified];
          ELSE
            new_program_attributes^.starting_procedure := pvt [p$starting_procedure].value^.
                  program_name_value;
            new_program_attributes^.contents := new_program_attributes^.contents +
                  $pmt$prog_description_contents [pmc$starting_proc_specified];
          IFEND;
        IFEND;

        IF pvt [p$load_map].specified THEN
          CASE pvt [p$load_map].value^.kind OF
          = clc$keyword = { keyword = unspecified}
            new_program_attributes^.contents := new_program_attributes^.contents -
                  $pmt$prog_description_contents [pmc$load_map_file_specified];
          = clc$file =
            new_program_attributes^.load_map_file := pvt [p$load_map].value^.file_value^;
            new_program_attributes^.contents := new_program_attributes^.contents +
                  $pmt$prog_description_contents [pmc$load_map_file_specified];
          ELSE {clc$string}
            new_program_attributes^.load_map_file := pvt [p$load_map].value^.string_value^;
            new_program_attributes^.contents := new_program_attributes^.contents +
                  $pmt$prog_description_contents [pmc$load_map_file_specified];
          CASEND;
        IFEND;

        IF pvt [p$load_map_option].specified THEN
          new_program_attributes^.contents := new_program_attributes^.contents +
                $pmt$prog_description_contents [pmc$load_map_options_specified];
          IF pvt [p$load_map_option].value^.kind = clc$keyword THEN
            IF pvt [p$load_map_option].value^.keyword_value = unspecified THEN
              new_program_attributes^.contents := new_program_attributes^.contents -
                    $pmt$prog_description_contents [pmc$load_map_options_specified];
            ELSEIF pvt [p$load_map_option].value^.keyword_value = 'ALL' THEN
              new_program_attributes^.load_map_options := -$pmt$load_map_options [pmc$no_load_map];
            ELSE {NONE}
              new_program_attributes^.load_map_options := $pmt$load_map_options [pmc$no_load_map];
            IFEND;
          ELSE {clc$list of clc$keyword}
            new_program_attributes^.load_map_options := $pmt$load_map_options [];
            node := pvt [p$load_map_option].value;
            WHILE (node <> NIL) AND (node^.element_value <> NIL) DO
              IF node^.element_value^.keyword_value = 'SEGMENT' THEN
                new_program_attributes^.load_map_options := new_program_attributes^.load_map_options +
                      $pmt$load_map_options [pmc$segment_map];
              ELSEIF node^.element_value^.keyword_value = 'BLOCK' THEN
                new_program_attributes^.load_map_options := new_program_attributes^.load_map_options +
                      $pmt$load_map_options [pmc$block_map];
              ELSEIF node^.element_value^.keyword_value = 'ENTRY_POINT' THEN
                new_program_attributes^.load_map_options := new_program_attributes^.load_map_options +
                      $pmt$load_map_options [pmc$entry_point_map];
              ELSE {CROSS_REFERENCE}
                new_program_attributes^.load_map_options := new_program_attributes^.load_map_options +
                      $pmt$load_map_options [pmc$entry_point_xref];
              IFEND;
              node := node^.link;
            WHILEND;
          IFEND;
        IFEND;

        IF pvt [p$termination_error_level].specified THEN
          new_program_attributes^.contents := new_program_attributes^.contents +
                $pmt$prog_description_contents [pmc$term_error_level_specified];
          IF pvt [p$termination_error_level].value^.keyword_value = unspecified THEN
            new_program_attributes^.contents := new_program_attributes^.contents -
                  $pmt$prog_description_contents [pmc$term_error_level_specified];
          ELSEIF pvt [p$termination_error_level].value^.keyword_value = 'WARNING' THEN
            new_program_attributes^.termination_error_level := pmc$warning_load_errors;
          ELSEIF pvt [p$termination_error_level].value^.keyword_value = 'ERROR' THEN
            new_program_attributes^.termination_error_level := pmc$error_load_errors;
          ELSE {FATAL}
            new_program_attributes^.termination_error_level := pmc$fatal_load_errors;
          IFEND;
        IFEND;

        IF pvt [p$preset_value].specified THEN
          new_program_attributes^.contents := new_program_attributes^.contents +
                $pmt$prog_description_contents [pmc$preset_specified];
          IF pvt [p$preset_value].value^.keyword_value = unspecified THEN
            new_program_attributes^.contents := new_program_attributes^.contents -
                  $pmt$prog_description_contents [pmc$preset_specified];
          ELSEIF pvt [p$preset_value].value^.keyword_value = 'ZERO' THEN
            new_program_attributes^.preset := pmc$initialize_to_zero;
          ELSEIF pvt [p$preset_value].value^.keyword_value = 'INFINITY' THEN
            new_program_attributes^.preset := pmc$initialize_to_infinity;
          ELSEIF pvt [p$preset_value].value^.keyword_value = 'FLOATING_POINT_INDEFINITE' THEN
            new_program_attributes^.preset := pmc$initialize_to_indefinite;
          ELSE {ALTERNATE_ONES}
            new_program_attributes^.preset := pmc$initialize_to_alt_ones;
          IFEND;
        IFEND;

        IF pvt [p$stack_size].specified THEN
          IF pvt [p$stack_size].value^.kind = clc$keyword { keyword = unspecified} THEN
            new_program_attributes^.contents := new_program_attributes^.contents -
                  $pmt$prog_description_contents [pmc$max_stack_size_specified];
          ELSE {clc$integer}
            new_program_attributes^.contents := new_program_attributes^.contents +
                  $pmt$prog_description_contents [pmc$max_stack_size_specified];
            new_program_attributes^.maximum_stack_size := pvt [p$stack_size].value^.integer_value.value;
          IFEND;
        IFEND;

        IF pvt [p$abort_file].specified THEN
          CASE pvt [p$abort_file].value^.kind OF
          = clc$keyword = { keyword = unspecified}
            new_program_attributes^.contents := new_program_attributes^.contents -
                  $pmt$prog_description_contents [pmc$abort_file_specified];
          = clc$file =
            new_program_attributes^.contents := new_program_attributes^.contents +
                  $pmt$prog_description_contents [pmc$abort_file_specified];
            new_program_attributes^.abort_file := pvt [p$abort_file].value^.file_value^;
          ELSE {clc$string}
            new_program_attributes^.contents := new_program_attributes^.contents +
                  $pmt$prog_description_contents [pmc$abort_file_specified];
            new_program_attributes^.abort_file := pvt [p$abort_file].value^.string_value^;
          CASEND;
        IFEND;

        IF pvt [p$debug_input].specified THEN
          CASE pvt [p$debug_input].value^.kind OF
          = clc$keyword = { keyword = unspecified}
            new_program_attributes^.contents := new_program_attributes^.contents -
                  $pmt$prog_description_contents [pmc$debug_input_specified];
          = clc$file =
            new_program_attributes^.contents := new_program_attributes^.contents +
                  $pmt$prog_description_contents [pmc$debug_input_specified];
            new_program_attributes^.debug_input := pvt [p$debug_input].value^.file_value^;
          ELSE {clc$string}
            new_program_attributes^.contents := new_program_attributes^.contents +
                  $pmt$prog_description_contents [pmc$debug_input_specified];
            new_program_attributes^.debug_input := pvt [p$debug_input].value^.string_value^;
          CASEND;
        IFEND;

        IF pvt [p$debug_output].specified THEN
          CASE pvt [p$debug_output].value^.kind OF
          = clc$keyword = { keyword = unspecified}
            new_program_attributes^.contents := new_program_attributes^.contents -
                  $pmt$prog_description_contents [pmc$debug_output_specified];
          = clc$file =
            new_program_attributes^.contents := new_program_attributes^.contents +
                  $pmt$prog_description_contents [pmc$debug_output_specified];
            new_program_attributes^.debug_output := pvt [p$debug_output].value^.file_value^;
          ELSE {clc$string}
            new_program_attributes^.contents := new_program_attributes^.contents +
                  $pmt$prog_description_contents [pmc$debug_output_specified];
            new_program_attributes^.debug_output := pvt [p$debug_output].value^.string_value^;
          CASEND;
        IFEND;

        IF pvt [p$debug_mode].specified THEN
          IF pvt [p$debug_mode].value^.kind = clc$keyword { keyword = unspecified} THEN
            new_program_attributes^.contents := new_program_attributes^.contents -
                  $pmt$prog_description_contents [pmc$debug_mode_specified];
          ELSE {clc$boolean}
            new_program_attributes^.contents := new_program_attributes^.contents +
                  $pmt$prog_description_contents [pmc$debug_mode_specified];
            new_program_attributes^.debug_mode := pvt [p$debug_mode].value^.boolean_value.value;
          IFEND;
        IFEND;

        IF pvt [p$availability].specified THEN
          IF pvt [p$availability].value^.keyword_value = 'NORMAL_USAGE' THEN
            new_program_description_header^.command_function_availability := clc$normal_usage_entry;
          ELSEIF pvt [p$availability].value^.keyword_value = 'ADVANCED_USAGE' THEN
            new_program_description_header^.command_function_availability := clc$advanced_usage_entry;
          ELSE {HIDDEN}
            new_program_description_header^.command_function_availability := clc$hidden_entry;
          IFEND;
        IFEND;

        IF pvt [p$scope].specified THEN
          IF pvt [p$scope].value^.keyword_value = 'XDCL' THEN
            new_program_description_header^.command_function_kind := llc$entry_point;
          ELSEIF pvt [p$scope].value^.keyword_value = 'GATE' THEN
            new_program_description_header^.command_function_kind := llc$gate;
          ELSE {LOCAL}
            new_program_description_header^.command_function_kind := llc$local_to_library;
          IFEND;
        IFEND;

        IF pvt [p$log_option].specified THEN
          IF pvt [p$log_option].value^.keyword_value = 'AUTOMATIC' THEN
            new_program_description_header^.command_log_option := clc$automatically_log;
          ELSE {MANUAL}
            new_program_description_header^.command_log_option := clc$manually_log;
          IFEND;
        IFEND;

        pmp$get_time (osc$hms_time, time, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
        pmp$get_date (osc$mdy_date, date, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
        new_program_description_header^.time_created := time;
        new_program_description_header^.date_created := date;

        ALLOCATE module_description IN ocv$olg_working_heap^;
        IF module_description = NIL THEN
          osp$set_status_condition (oce$e_internal_olg_seg_overflow, status);
          RETURN;
        IFEND;

        module_description^.name := new_program_description_header^.name;
        module_description^.source := occ$current;
        IF new_application_identifier = NIL THEN
          module_description^.kind := occ$program_description;
        ELSE
          module_description^.kind := occ$applic_program_description;
        IFEND;

        size := i#current_sequence_position (ocv$olg_scratch_seq);
        RESET ocv$olg_scratch_seq;

        ALLOCATE module_description^.file: [[REP size OF cell]] IN ocv$olg_working_heap^;
        IF module_description^.file = NIL THEN
          osp$set_status_condition (oce$e_internal_olg_seg_overflow, status);
          RETURN;
        IFEND;

        IF #SEGMENT (nlm^.description^.file) = #SEGMENT (ocv$olg_working_heap) THEN
          FREE nlm^.description^.file IN ocv$olg_working_heap^;
        IFEND;
        nlm^.description := module_description;
        nlm^.description^.file := module_description^.file;

        RESET module_description^.file;

        IF new_application_identifier = NIL THEN
          NEXT module_description^.program_description_header IN module_description^.file;
          NEXT new_program_description_header IN ocv$olg_scratch_seq;
          module_description^.program_description_header^ := new_program_description_header^;
          IF module_description^.program_description_header^.number_of_aliases <> 0 THEN
            NEXT new_alias_list: [1 .. module_description^.program_description_header^.number_of_aliases] IN
                  module_description^.file;
            module_description^.program_description_header^.aliases :=
                  #REL (new_alias_list, module_description^.file^);
            NEXT old_alias_list: [1 .. module_description^.program_description_header^.number_of_aliases] IN
                  ocv$olg_scratch_seq;
            new_alias_list^ := old_alias_list^;
          IFEND;
        ELSE
          NEXT module_description^.applic_program_description_hdr IN module_description^.file;
          NEXT new_applic_program_header IN ocv$olg_scratch_seq;
          module_description^.applic_program_description_hdr^ := new_applic_program_header^;
          IF module_description^.applic_program_description_hdr^.library_member_header.number_of_aliases <>
                0 THEN
            NEXT new_alias_list: [1 .. module_description^.applic_program_description_hdr^.
                  library_member_header.number_of_aliases] IN module_description^.file;
            module_description^.applic_program_description_hdr^.library_member_header.aliases :=
                  #REL (new_alias_list, module_description^.file^);

            NEXT old_alias_list: [1 .. module_description^.applic_program_description_hdr^.
                  library_member_header.number_of_aliases] IN ocv$olg_scratch_seq;
            new_alias_list^ := old_alias_list^;
          IFEND;
        IFEND;

        member_size := size - i#current_sequence_position (module_description^.file);
        NEXT member: [[REP member_size OF cell]] IN module_description^.file;
        IF new_application_identifier = NIL THEN
          module_description^.program_description_header^.member := #REL (member, module_description^.file^);
          module_description^.program_description_header^.member_size := member_size;
        ELSE
          module_description^.applic_program_description_hdr^.library_member_header.member :=
                #REL (member, module_description^.file^);
          module_description^.applic_program_description_hdr^.library_member_header.member_size :=
                member_size;
        IFEND;

        NEXT sequence: [[REP member_size OF cell]] IN ocv$olg_scratch_seq;
        member^ := sequence^;
        name_node := name_node^.link;
      WHILEND;

    END /protect/;
    pmp$disestablish_cond_handler (established_conditions, ignore_status);

  PROCEND ocp$_change_program_description;

MODEND ocm$change_program_description;
