?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE MANAGE_MEMORY - a command utility' ??
MODULE mmm$manage_memory;
?? RIGHT := 110 ??

{ PURPOSE:
{   This module contains the processors of the Manage Memory Utility.  The main program mmp$manage_memory
{   is called by SCL to process the system command MANAGE_MEMORY.  The only result of the MANAGE_MEMORY
{   command is to establish the Manage_Memory Command Utility which activates the following commands:
{
{                  CHANGE_MEMORY_ATTRIBUTE
{                  CHANGE_SHARED_QUEUE_ATTRIBUTE
{                  DISPLAY_MEMORY_ATTRIBUTE
{                  DISPLAY_SHARED_QUEUE_ATTRIBUTE
{                  DISPLAY_SHARED_QUEUE_CYCLES
{                  QUIT
{                  SET_TO_DEFAULT
{
{ DESIGN:
{   The base premise of this design is that the Manage_Memory Utility will execute infrequently.  All of the
{   code in this module is in procedures.  There is one procedure for each of the commands plus one procedure
{   for the initiation of the utility which is the Manage_Memory command.  Ring 3 and Ring 1 helper routines
{   are used to read and write the variables that are displayed and/or changed by the Manage_Memory utility.
{
{ NOTES:
{   SECURITY - The ring3 helper routines that store data do enforce security by rejecting with appropriate
{     status any request that is not from the system job.  Any user is allowed to display the data.
{   TESTBED - It is easy to check the MMU commands from a terminal.  Construct a testbed module to duplicate
{     the XDCL declarations needed by the MMU (the MMV$ variables plus MMV$GPQL) as they are found in
{     mmm$page_fault_processor and mmm$monitor_request_processor.  Also add a dummy system job function.  Then
{     compile mmm$manage_memory, mmm$manage_memory_helper_r3, and mmm$ring1_helper plus the testbed module.
{     Execute via execute_task with mmp$manage_memory as the entry point.
{   ADDITIONAL ENTRIES:  Adding a new queue will required minor code changes.  A new memory attribute
{     variable can be added by:
{       1. Add a new "mmc$mmu_ma_xxx" ordinal to mmt$mmu_memory_attributes in deck mmt$manage_memory_utility.
{       2. In mmm$ring1_helper add a pointer entry to the array mmt$mmu_ma_data which is one of the
{          fields in the record mmv$mmu_manage_memory_utility.
{       3. In mmm$manage_memory add an entry to the array v$mmu_info_ma.
{       4. Change the PDT of the commands chama and disma to add the new parameter name.
{       5. If appropriate, add a constant definition to deck mmc$manage_memory_utility.

?? NEWTITLE := 'Global Declarations Referenced by this Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc cle$not_yet_implemented
*copyc clt$path_display_chunks
*copyc mmc$manage_memory_utility
*copyc mmt$manage_memory_utility
*copyc mmt$page_frame_queue_id
*copyc mmt$page_queue_list
*copyc oss$job_paged_literal
*copyc oss$task_private
*copyc ost$date
*copyc ost$time
*copyc pmt$os_name
?? POP ??
*copyc clf#make_clt$integer_value
*copyc clf#make_keyword_value
*copyc clf#make_list_value
*copyc clf#make_record_header_value
*copyc clp#add_record_field

*copyc clp$begin_utility
*copyc clp$build_standard_title
*copyc clp$close_display
*copyc clp$convert_integer_to_rjstring
*copyc clp$convert_integer_to_string
*copyc clp$end_include
*copyc clp$end_utility
*copyc clp$evaluate_parameters
*copyc clp$include_file
*copyc clp$new_display_line
*copyc clp$new_display_page
*copyc clp$open_display_reference
*copyc clp$put_display
*copyc clp$reset_for_next_display_page
*copyc clp$right_justify_string
*copyc mmp$fetch_dynamic_aging_enab_r3
*copyc mmp$fetch_manage_memory_data_r3
*copyc mmp$fetch_site_active_q_cnt_r3
*copyc mmp$reset_dynamic_aging_r3
*copyc mmp$store_manage_memory_data_r3
*copyc ofp$display_status_message
*copyc osp$append_status_integer
*copyc osp$append_status_parameter
*copyc osp$disestablish_cond_handler
*copyc osp$establish_block_exit_hndlr
*copyc osp$establish_condition_handler
*copyc osp$set_status_abnormal
*copyc osp$set_status_condition
*copyc osp$set_status_from_condition
*copyc pmp$continue_to_cause
?? EJECT ??
*copyc clv$nil_display_control
?? OLDTITLE ??
?? NEWTITLE := 'Global Declarations Declared by this Module', EJECT ??

  CONST
    c$max_line_size = 79,
    c$utility_name = 'MANAGE_MEMORY                  ';

  CONST
    c$page_queue_age_cycle_min = mmc$page_queue_age_cycle_min + 1,
    c$page_queue_age_cycle_max = mmc$page_queue_age_cycle_max + 1;

  TYPE
    t$page_queue_age_cycle = c$page_queue_age_cycle_min .. c$page_queue_age_cycle_max;

  TYPE
    t$memory_attribute_info = record
      index: mmt$mmu_memory_attributes,
      name: string (osc$max_name_size),
      units_name: string (13),
    recend,

    t$memory_attributes = set of mmt$mmu_memory_attributes,
    t$shared_queues = set of mmt$global_page_queue_index;

  TYPE
    t$force_dynamic_aging_attribute = (c$display_memory_attributes, c$display_shared_queue_attrib,
          c$change_memory_attributes, c$change_shared_queue_attrib),
    t$force_dynamic_aging_attribs = set of t$force_dynamic_aging_attribute,
    mmt$mmu_debug_options = record
      force_dynamic_aging_attributes: t$force_dynamic_aging_attribs,
    recend;

?? EJECT ??

  VAR
    v$dissqa_data: [STATIC, READ, oss$job_paged_literal] array
          [mmc$pq_shared_first .. mmc$pq_shared_first_site] of string (20) := ['TASK_SERVICE        ',
          'EXECUTABLE_FILE     ', 'NON_EXECUTABLE_FILE ', 'DEVICE_FILE         ', 'FILE_SERVER         ',
          'OTHER               ', 'SITE_XX             '],

    { When the command DISPLAY_MEMORY_ATTRIBUTE is executed, the memory attributes will be displayed in the
    { order that they are listed in the array below.  The order currently used groups the attributes according
    { to their units.

?? FMT (FORMAT := OFF) ??
    v$mmu_info_ma: [STATIC, READ, oss$job_paged_literal]
          ARRAY [mmt$mmu_memory_attributes] OF t$memory_attribute_info := [
          [mmc$mmu_ma_aic,    'AGE_INTERVAL_CEILING',            'age_intervals'],
          [mmc$mmu_ma_aif,    'AGE_INTERVAL_FLOOR',              'age_intervals'],
          [mmc$mmu_ma_aal,    'AGGRESSIVE_AGING_LEVEL',          '  pages'],
          [mmc$mmu_ma_aal2,   'AGGRESSIVE_AGING_LEVEL_2',        '  pages'],
          [mmc$mmu_ma_aa,     'AGING_ALGORITHM',                 '        '],
          [mmc$mmu_ma_amqmax, 'AVAILABLE_MODIFIED_QUEUE_MAX',    '  pages'],
          [mmc$mmu_ma_amqmin, 'AVAILABLE_MODIFIED_QUEUE_MIN',    '  pages'],
          [mmc$mmu_ma_amqfm,  'AVAILABLE_MODIFIED_Q_FLOOR_MIN',  '  pages'],
          [mmc$mmu_ma_amqdpt, 'AVAILABLE_MOD_Q_DEC_PER_TASK',    '  pages'],
          [mmc$mmu_ma_amwqdi, 'AVAIL_MOD_WAIT_Q_DEQ_INTERVAL',   'microseconds'],
          [mmc$mmu_ma_mwqdi,  'MEMORY_WAIT_Q_DEQUEUE_INTERVAL',  'microseconds'],
          [mmc$mmu_ma_ieqai,  'IO_ERROR_QUEUE_AGE_INTERVAL',     'microseconds'],
          [mmc$mmu_ma_jwsai,  'JOB_WORKING_SET_AGE_INTERVAL',    'microseconds'],
          [mmc$mmu_ma_minap,  'MINIMUM_AVAILABLE_PAGES',         '  pages'],
          [mmc$mmu_ma_psp,    'PAGE_STREAMING_PRESTREAM',        'page faults '],
          [mmc$mmu_ma_psrl,   'PAGE_STREAMING_RANDOM_LIMIT',     'page faults '],
          [mmc$mmu_ma_psr,    'PAGE_STREAMING_READS',            'transfer unit'],
          [mmc$mmu_ma_pst,    'PAGE_STREAMING_THRESHOLD   ',     '  bytes     '],
          [mmc$mmu_ma_psts,   'PAGE_STREAMING_TRANSFER_SIZE',    '  bytes     '],
          [mmc$mmu_ma_pci,    'PERIODIC_CALL_INTERVAL',          'microseconds'],
          [mmc$mmu_ma_swsai,  'SHARED_WORKING_SET_AGE_INTERVAL', 'microseconds'],
          [mmc$mmu_ma_sam,    'SWAPPING_AIC_MODIFIED',           'swapout(s)'],
          [mmc$mmu_ma_sau,    'SWAPPING_AIC_UNMODIFIED',         'swapout(s)'],
          [mmc$mmu_ma_tt,     'TICK_TIME',                       'microseconds'],
          [mmc$mmu_ma_daf,    'DYNAMIC_AVAILABLE_FLOOR',         '  pages'],
          [mmc$mmu_ma_daem,   'DYNAMIC_AVAILABLE_EMERGENCY_MIN', '  pages'],
          [mmc$mmu_ma_damax,  'DYNAMIC_AVAILABLE_MAX',           '  pages'],
          [mmc$mmu_ma_damin,  'DYNAMIC_AVAILABLE_MIN',           '  pages'],
          [mmc$mmu_ma_dnim,   'DYNAMIC_NEGATIVE_INCREMENT_MAX',  '  pages'],
          [mmc$mmu_ma_dpim,   'DYNAMIC_POSITIVE_INCREMENT_MAX',  '  pages']],
?? FMT (FORMAT := ON) ??

    v$shared_system_queues: [STATIC, READ, oss$job_paged_literal] t$shared_queues :=
          [mmc$pq_shared_task_service, mmc$pq_shared_pf_execute, mmc$pq_shared_pf_non_execute,
          mmc$pq_shared_device_file, mmc$pq_shared_file_server, mmc$pq_shared_other],

    v$dynamic_memory_attributes: [STATIC, READ, oss$job_paged_literal] t$memory_attributes :=
          $t$memory_attributes [mmc$mmu_ma_daf, mmc$mmu_ma_daem, mmc$mmu_ma_damax, mmc$mmu_ma_damin,
          mmc$mmu_ma_dnim, mmc$mmu_ma_dpim];

{ begin of temporary for debugging purpose ...

  VAR
    mmv$debug_options: [XREF] mmt$mmu_debug_options;

  PROCEDURE [XREF] mmp$mmu_set_debug_options
    (  debug_options: mmt$mmu_debug_options);

{ end of temporary for debugging purpose ...

?? OLDTITLE ??
?? NEWTITLE := 'change_memory_attribute', EJECT ??

{ PURPOSE:
{   This procedure processes the CHANGE_MEMORY_ATTRIBUTE Command.  The command provides the capability to
{   change various memory attributes.  These are various variables defined in mainframe wired modules of
{   EXEC's memory management.

  PROCEDURE change_memory_attribute
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

    VAR
      dynamic_aging_enabled: boolean;

?? NEWTITLE := 'change_memory_attribute_normal', EJECT ??

    PROCEDURE change_memory_attribute_normal
      (    parameter_list: clt$parameter_list;
       VAR status: ost$status);

*copyc mmd$mmu_change_memory_attribute

      VAR
        v$pdt_mmu_index_converter: [STATIC, READ, oss$job_paged_literal] array [1 .. p$status - 1] of
              mmt$mmu_memory_attributes := [
{ P$AGE_INTERVAL_CEILING               } mmc$mmu_ma_aic,
{ P$AGE_INTERVAL_FLOOR                 } mmc$mmu_ma_aif,
{ P$AGGRESSIVE_AGING_LEVEL             } mmc$mmu_ma_aal,
{ P$AGGRESSIVE_AGING_LEVEL_2           } mmc$mmu_ma_aal2,
{ P$AGING_ALGORITHM                    } mmc$mmu_ma_aa,
{ P$AVAILABLE_MODIFIED_QUEUE_MAX       } mmc$mmu_ma_amqmax,
{ P$AVAILABLE_MODIFIED_QUEUE_MIN       } mmc$mmu_ma_amqmin,
{ P$AVAILABLE_MODIFIED_Q_FLOOR_MI      } mmc$mmu_ma_amqfm,
{ P$AVAILABLE_MOD_Q_DEC_PER_TASK       } mmc$mmu_ma_amqdpt,
{ P$AVAIL_MOD_WAIT_Q_DEQ_INTERVAL      } mmc$mmu_ma_amwqdi,
{ P$MEMORY_WAIT_Q_DEQUEUE_INTERVA      } mmc$mmu_ma_mwqdi,
{ P$IO_ERROR_QUEUE_AGE_INTERVAL        } mmc$mmu_ma_ieqai,
{ P$JOB_WORKING_SET_AGE_INTERVAL       } mmc$mmu_ma_jwsai,
{ P$MINIMUM_AVAILABLE_PAGES            } mmc$mmu_ma_minap,
{ P$PAGE_STREAMING_RANDOM_LIMIT        } mmc$mmu_ma_psrl,
{ P$PAGE_STREAMING_READS               } mmc$mmu_ma_psr,
{ P$PAGE_STREAMING_PRESTREAM           } mmc$mmu_ma_psp,
{ P$PAGE_STREAMING_THRESHOLD           } mmc$mmu_ma_pst,
{ P$PAGE_STREAMING_TRANSFER_SIZE       } mmc$mmu_ma_psts,
{ P$PERIODIC_CALL_INTERVAL             } mmc$mmu_ma_pci,
{ P$SHARED_WORKING_SET_AGE_INTERV      } mmc$mmu_ma_swsai,
{ P$SWAPPING_AIC_MODIFIED              } mmc$mmu_ma_sam,
{ P$SWAPPING_AIC_UNMODIFIED            } mmc$mmu_ma_sau,
{ P$TICK_TIME                          } mmc$mmu_ma_tt];

      VAR
        gpql_default: mmt$mmu_gpql_default,
        i: integer,
        ma_default: mmt$mmu_ma_default,
        ma_values: mmt$mmu_ma_values,
        queues: mmt$global_page_queue_list;

      status.normal := TRUE;
      clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;

      mmp$fetch_manage_memory_data_r3 (queues, ma_values, gpql_default, ma_default);
      FOR i := LOWERBOUND (v$pdt_mmu_index_converter) TO UPPERBOUND (v$pdt_mmu_index_converter) DO
        IF pvt [i].specified THEN
          IF pvt [i].value^.kind = clc$integer THEN
            ma_values [v$pdt_mmu_index_converter [i]] := pvt [i].value^.integer_value.value;
          ELSE
            ma_values [v$pdt_mmu_index_converter [i]] := ma_default [v$pdt_mmu_index_converter [i]];
          IFEND;
        IFEND;
      FOREND;

      mmp$store_manage_memory_data_r3 (FALSE {= do not reset dynamic aging} , queues, ma_values, status);

    PROCEND change_memory_attribute_normal;
?? OLDTITLE ??
?? NEWTITLE := 'change_memory_attribute_dynamic', EJECT ??

    PROCEDURE change_memory_attribute_dynamic
      (    parameter_list: clt$parameter_list;
       VAR status: ost$status);

*copyc mmd$mmu_change_memory_attr_dyn

      VAR
        v$pdt_mmu_index_converter: [STATIC, READ, oss$job_paged_literal] array [1 .. p$status - 1] of
              mmt$mmu_memory_attributes := [
{ P$AGE_INTERVAL_CEILING               } mmc$mmu_ma_aic,
{ P$AGE_INTERVAL_FLOOR                 } mmc$mmu_ma_aif,
{ P$AGGRESSIVE_AGING_LEVEL             } mmc$mmu_ma_aal,
{ P$AGGRESSIVE_AGING_LEVEL_2           } mmc$mmu_ma_aal2,
{ P$AGING_ALGORITHM                    } mmc$mmu_ma_aa,
{ P$AVAILABLE_MODIFIED_QUEUE_MAX       } mmc$mmu_ma_amqmax,
{ P$AVAILABLE_MODIFIED_QUEUE_MIN       } mmc$mmu_ma_amqmin,
{ P$DYNAMIC_AVAILABLE_FLOOR            } mmc$mmu_ma_daf,
{ P$DYNAMIC_AVAILABLE_EMERGENCY_M      } mmc$mmu_ma_daem,
{ P$DYNAMIC_AVAILABLE_MAX              } mmc$mmu_ma_damax,
{ P$DYNAMIC_AVAILABLE_MIN              } mmc$mmu_ma_damin,
{ P$DYNAMIC_NEGATIVE_INCREMENT_MA      } mmc$mmu_ma_dnim,
{ P$DYNAMIC_POSITIVE_INCREMENT_MA      } mmc$mmu_ma_dpim,
{ P$AVAILABLE_MODIFIED_Q_FLOOR_MI      } mmc$mmu_ma_amqfm,
{ P$AVAILABLE_MOD_Q_DEC_PER_TASK       } mmc$mmu_ma_amqdpt,
{ P$AVAIL_MOD_WAIT_Q_DEQ_INTERVAL      } mmc$mmu_ma_amwqdi,
{ P$MEMORY_WAIT_Q_DEQUEUE_INTERVA      } mmc$mmu_ma_mwqdi,
{ P$IO_ERROR_QUEUE_AGE_INTERVAL        } mmc$mmu_ma_ieqai,
{ P$JOB_WORKING_SET_AGE_INTERVAL       } mmc$mmu_ma_jwsai,
{ P$MINIMUM_AVAILABLE_PAGES            } mmc$mmu_ma_minap,
{ P$PAGE_STREAMING_RANDOM_LIMIT        } mmc$mmu_ma_psrl,
{ P$PAGE_STREAMING_READS               } mmc$mmu_ma_psr,
{ P$PAGE_STREAMING_PRESTREAM           } mmc$mmu_ma_psp,
{ P$PAGE_STREAMING_THRESHOLD           } mmc$mmu_ma_pst,
{ P$PAGE_STREAMING_TRANSFER_SIZE       } mmc$mmu_ma_psts,
{ P$PERIODIC_CALL_INTERVAL             } mmc$mmu_ma_pci,
{ P$SHARED_WORKING_SET_AGE_INTERV      } mmc$mmu_ma_swsai,
{ P$SWAPPING_AIC_MODIFIED              } mmc$mmu_ma_sam,
{ P$SWAPPING_AIC_UNMODIFIED            } mmc$mmu_ma_sau,
{ P$TICK_TIME                          } mmc$mmu_ma_tt];

      VAR
        gpql_default: mmt$mmu_gpql_default,
        i: integer,
        ma_default: mmt$mmu_ma_default,
        ma_values: mmt$mmu_ma_values,
        queues: mmt$global_page_queue_list;

      status.normal := TRUE;
      clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;

      mmp$fetch_manage_memory_data_r3 (queues, ma_values, gpql_default, ma_default);
      FOR i := LOWERBOUND (v$pdt_mmu_index_converter) TO UPPERBOUND (v$pdt_mmu_index_converter) DO
        IF pvt [i].specified THEN
          IF pvt [i].value^.kind = clc$integer THEN
            ma_values [v$pdt_mmu_index_converter [i]] := pvt [i].value^.integer_value.value;
          ELSE
            ma_values [v$pdt_mmu_index_converter [i]] := ma_default [v$pdt_mmu_index_converter [i]];
          IFEND;
        IFEND;
      FOREND;

      mmp$store_manage_memory_data_r3 (FALSE {= do not reset dynamic aging} , queues, ma_values, status);

    PROCEND change_memory_attribute_dynamic;
?? OLDTITLE ??
?? EJECT ??

    mmp$fetch_dynamic_aging_enab_r3 (dynamic_aging_enabled);
    IF dynamic_aging_enabled OR (c$change_memory_attributes IN mmv$debug_options.
        force_dynamic_aging_attributes) THEN
      change_memory_attribute_dynamic (parameter_list, status);
    ELSE
      change_memory_attribute_normal (parameter_list, status);
    IFEND;

  PROCEND change_memory_attribute;
?? OLDTITLE ??
?? NEWTITLE := 'change_shared_queue_attribute', EJECT ??

{ PURPOSE:
{   This procedure processes the CHANGE_SHARED_QUEUE_ATTRIBUTE Command.  The command provides the capability
{   to change the attributes of the shared queues which affect the rate of aging and the number of pages in
{   each of the shared queues.  The attributes are in the global page queue list headers which are found in
{   mainframe wired modules of EXEC's memory management.

  PROCEDURE change_shared_queue_attribute
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

    VAR
      dynamic_aging_enabled: boolean;

?? NEWTITLE := 'add_age_cycle', EJECT ??

{ PURPOSE:
{   This request adds an integer value to the EVALUATED_AGE_CYCLES set.
{
{ NOTE:
{   MMT$PAGE_QUEUE_AGE_CYCLES is a set biased by 0, where the passed integer
{   value is biased by 1. (EVALUATED_AGE_CYCLE = integer value - 1)

    PROCEDURE add_age_cycle
      (    value: integer;
       VAR evaluated_age_cycles: mmt$page_queue_age_cycles;
       VAR status: ost$status);

      IF (value < c$page_queue_age_cycle_min) OR (value > c$page_queue_age_cycle_max) THEN
        osp$set_status_abnormal ('CL', cle$integer_out_of_range, 'Age Cycle ', status);
        osp$append_status_integer (' ', value, 10 {= radix} , FALSE {= exclude radix} , status);
        osp$append_status_integer (osc$status_parameter_delimiter, value, 10 {= radix} , FALSE
              {= exclude radix} , status);
        osp$append_status_integer (osc$status_parameter_delimiter, value, 10 {= radix} , FALSE
              {= exclude radix} , status);
        RETURN; {----->
      ELSE
        evaluated_age_cycles := evaluated_age_cycles + $mmt$page_queue_age_cycles [value - 1];
      IFEND;

    PROCEND add_age_cycle;
?? OLDTITLE ??
?? NEWTITLE := 'change_shared_queue_att_normal', EJECT ??

    PROCEDURE change_shared_queue_att_normal
      (    parameter_list: clt$parameter_list;
       VAR status: ost$status);

*copyc mmd$mmu_change_shared_q_attrib

      VAR
        evaluated_age_cycles: mmt$page_queue_age_cycles,
        gpql_default: mmt$global_page_queue_list,
        ignore_memory_attrib_selected: boolean,
        ma_default: mmt$mmu_ma_default,
        ma_values: mmt$mmu_ma_values,
        queue_id: mmt$page_frame_queue_id,
        queues: mmt$global_page_queue_list,
        queues_selected: t$shared_queues;

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

      evaluated_age_cycles := -$mmt$page_queue_age_cycles [];
      IF pvt [p$age_cycles].specified THEN
        evaluate_age_cycles (pvt [p$age_cycles].value, evaluated_age_cycles, status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
      IFEND;

      IF (pvt [p$age_interval_ceiling].specified)
{ } AND ((pvt [p$age_interval_modified].specified) OR (pvt [p$age_interval_unmodified].specified)) THEN

        { This is a dumb error code, but I don't want to create a new one ...
        osp$set_status_abnormal ('CL', cle$not_yet_implemented, 'Parameter AIC together with AIU or AIM',
              status);
        RETURN; {----->
      IFEND;

      evaluate_selected_queues (pvt [p$queue].value, queues_selected, ignore_memory_attrib_selected);

      mmp$fetch_manage_memory_data_r3 (queues, ma_values, gpql_default, ma_default);

      FOR queue_id := mmc$pq_shared_first TO mmc$pq_shared_last DO
        IF queue_id IN queues_selected THEN
          queues [queue_id].age_interval_nominal_modified :=
                f$queue_attribute_value (pvt [p$age_interval_modified],
                queues [queue_id].age_interval_nominal_modified,
                gpql_default [queue_id].age_interval_nominal_modified);

          queues [queue_id].age_interval_nominal_unmodified :=
                f$queue_attribute_value (pvt [p$age_interval_unmodified],
                queues [queue_id].age_interval_nominal_unmodified,
                gpql_default [queue_id].age_interval_nominal_unmodified);

          { AIC changes AICM and AICU, if specified
          queues [queue_id].age_interval_nominal_unmodified :=
                f$queue_attribute_value (pvt [p$age_interval_ceiling],
                queues [queue_id].age_interval_nominal_unmodified,
                gpql_default [queue_id].age_interval_nominal_unmodified);
          queues [queue_id].age_interval_nominal_modified :=
                f$queue_attribute_value (pvt [p$age_interval_ceiling],
                queues [queue_id].age_interval_nominal_modified,
                gpql_default [queue_id].age_interval_nominal_modified);

          queues [queue_id].age_interval_actual_modified := queues [queue_id].age_interval_nominal_modified;
          queues [queue_id].age_interval_modified_max := queues [queue_id].age_interval_nominal_modified;
          queues [queue_id].age_interval_modified_min := queues [queue_id].age_interval_nominal_modified;
          queues [queue_id].age_interval_neg_inc_modified := 0;
          queues [queue_id].age_interval_pos_inc_modified := 0;

          queues [queue_id].age_interval_actual_unmodified :=
                queues [queue_id].age_interval_nominal_unmodified;
          queues [queue_id].age_interval_unmodified_max := queues [queue_id].age_interval_nominal_unmodified;
          queues [queue_id].age_interval_unmodified_min := queues [queue_id].age_interval_nominal_unmodified;
          queues [queue_id].age_interval_neg_inc_unmodified := 0;
          queues [queue_id].age_interval_pos_inc_unmodified := 0;

          queues [queue_id].minimum_nominal := f$queue_attribute_value
                (pvt [p$minimum_size], queues [queue_id].minimum_nominal,
                gpql_default [queue_id].minimum_nominal);

          queues [queue_id].minimum_actual := queues [queue_id].minimum_nominal;
          queues [queue_id].minimum_min := queues [queue_id].minimum_nominal;
          queues [queue_id].minimum_max := queues [queue_id].minimum_nominal;
          queues [queue_id].minimum_neg_inc := 0;
          queues [queue_id].minimum_neg_inc_pc := 0;
          queues [queue_id].minimum_pos_inc := 0;
          queues [queue_id].minimum_pos_inc_pc := 0;

          queues [queue_id].maximum_nominal := f$queue_attribute_value
                (pvt [p$maximum_size], queues [queue_id].maximum_nominal,
                gpql_default [queue_id].maximum_nominal);

          queues [queue_id].maximum_actual := queues [queue_id].maximum_nominal;
          queues [queue_id].maximum_actual_cycle := queues [queue_id].maximum_nominal;
          queues [queue_id].maximum_min := queues [queue_id].maximum_nominal;
          queues [queue_id].maximum_max := queues [queue_id].maximum_nominal;
          queues [queue_id].maximum_neg_inc := 0;
          queues [queue_id].maximum_neg_inc_pc := 0;
          queues [queue_id].maximum_pos_inc := 0;
          queues [queue_id].maximum_pos_inc_pc := 0;

          IF pvt [p$age_cycles].specified THEN
            IF pvt [p$age_cycles].value^.kind <> clc$keyword THEN
              queues [queue_id].age_cycles := evaluated_age_cycles;
            ELSE
              queues [queue_id].age_cycles := gpql_default [queue_id].age_cycles;
            IFEND;
          IFEND;
        IFEND;
      FOREND;

      mmp$store_manage_memory_data_r3 (TRUE {= reset dynamic aging} , queues, ma_values, status);

    PROCEND change_shared_queue_att_normal;
?? OLDTITLE ??
?? NEWTITLE := 'change_shared_queue_att_dynamic', EJECT ??

    PROCEDURE change_shared_queue_att_dynamic
      (    parameter_list: clt$parameter_list;
       VAR status: ost$status);

*copyc mmd$mmu_change_shared_q_attr_d

      VAR
        evaluated_age_cycles: mmt$page_queue_age_cycles,
        gpql_default: mmt$global_page_queue_list,
        ignore_memory_attrib_selected: boolean,
        ma_default: mmt$mmu_ma_default,
        ma_values: mmt$mmu_ma_values,
        queue_id: mmt$page_frame_queue_id,
        queues: mmt$global_page_queue_list,
        queues_selected: t$shared_queues;

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

      evaluated_age_cycles := -$mmt$page_queue_age_cycles [];
      IF pvt [p$age_cycles].specified THEN
        evaluate_age_cycles (pvt [p$age_cycles].value, evaluated_age_cycles, status);
        IF NOT status.normal THEN
          RETURN; {----->
        IFEND;
      IFEND;

      IF (pvt [p$age_interval_ceiling].specified)
{   } AND ((pvt [p$age_interval_modified].specified) OR (pvt [p$age_interval_unmodified].specified)) THEN

        { This is a dumb error code, but I don't want to create a new one ...
        osp$set_status_abnormal ('CL', cle$not_yet_implemented, 'Parameter AIC together with AIU or AIM',
              status);
        RETURN; {----->
      IFEND;

      evaluate_selected_queues (pvt [p$queue].value, queues_selected, ignore_memory_attrib_selected);

      mmp$fetch_manage_memory_data_r3 (queues, ma_values, gpql_default, ma_default);

      FOR queue_id := mmc$pq_shared_first TO mmc$pq_shared_last DO
        IF queue_id IN queues_selected THEN
          queues [queue_id].queue_age_interval := f$queue_attribute_value
                (pvt [p$queue_age_interval], queues [queue_id].queue_age_interval,
                gpql_default [queue_id].queue_age_interval);
          queues [queue_id].encrease_min_enable_dynamic_age :=
                f$queue_attribute_value (pvt [p$encrease_min_enable_dynamic_a],
                queues [queue_id].encrease_min_enable_dynamic_age,
                gpql_default [queue_id].encrease_min_enable_dynamic_age);

          queues [queue_id].age_interval_nominal_modified :=
                f$queue_attribute_value (pvt [p$age_interval_modified],
                queues [queue_id].age_interval_nominal_modified,
                gpql_default [queue_id].age_interval_nominal_modified);
          queues [queue_id].age_interval_modified_min := f$queue_attribute_value
                (pvt [p$age_interval_modified_min], queues [queue_id].age_interval_modified_min,
                gpql_default [queue_id].age_interval_modified_min);
          queues [queue_id].age_interval_modified_max := f$queue_attribute_value
                (pvt [p$age_interval_modified_max], queues [queue_id].age_interval_modified_max,
                gpql_default [queue_id].age_interval_modified_max);
          queues [queue_id].age_interval_neg_inc_modified :=
                f$queue_attribute_value (pvt [p$age_interval_negative_inc_mod],
                queues [queue_id].age_interval_neg_inc_modified,
                gpql_default [queue_id].age_interval_neg_inc_modified);
          queues [queue_id].age_interval_pos_inc_modified :=
                f$queue_attribute_value (pvt [p$age_interval_positive_inc_mod],
                queues [queue_id].age_interval_pos_inc_modified,
                gpql_default [queue_id].age_interval_pos_inc_modified);

          queues [queue_id].age_interval_nominal_unmodified :=
                f$queue_attribute_value (pvt [p$age_interval_unmodified],
                queues [queue_id].age_interval_nominal_unmodified,
                gpql_default [queue_id].age_interval_nominal_unmodified);
          queues [queue_id].age_interval_unmodified_min := f$queue_attribute_value
                (pvt [p$age_interval_unmodified_min], queues [queue_id].age_interval_unmodified_min,
                gpql_default [queue_id].age_interval_unmodified_min);
          queues [queue_id].age_interval_unmodified_max := f$queue_attribute_value
                (pvt [p$age_interval_unmodified_max], queues [queue_id].age_interval_unmodified_max,
                gpql_default [queue_id].age_interval_unmodified_max);
          queues [queue_id].age_interval_neg_inc_unmodified :=
                f$queue_attribute_value (pvt [p$age_interval_negative_inc_unm],
                queues [queue_id].age_interval_neg_inc_unmodified,
                gpql_default [queue_id].age_interval_neg_inc_unmodified);
          queues [queue_id].age_interval_pos_inc_unmodified :=
                f$queue_attribute_value (pvt [p$age_interval_positive_inc_unm],
                queues [queue_id].age_interval_pos_inc_unmodified,
                gpql_default [queue_id].age_interval_pos_inc_unmodified);

          { AIC changes AICM and AICU, if specified
          queues [queue_id].age_interval_nominal_unmodified :=
                f$queue_attribute_value (pvt [p$age_interval_ceiling],
                queues [queue_id].age_interval_nominal_unmodified,
                gpql_default [queue_id].age_interval_nominal_unmodified);
          queues [queue_id].age_interval_nominal_modified :=
                f$queue_attribute_value (pvt [p$age_interval_ceiling],
                queues [queue_id].age_interval_nominal_modified,
                gpql_default [queue_id].age_interval_nominal_modified);


          queues [queue_id].minimum_nominal := f$queue_attribute_value
                (pvt [p$minimum_size], queues [queue_id].minimum_nominal,
                gpql_default [queue_id].minimum_nominal);
          queues [queue_id].minimum_min := f$queue_attribute_value
                (pvt [p$minimum_size_min], queues [queue_id].minimum_min, gpql_default [queue_id].
                minimum_min);
          queues [queue_id].minimum_max := f$queue_attribute_value
                (pvt [p$minimum_size_max], queues [queue_id].minimum_max, gpql_default [queue_id].
                minimum_max);
          queues [queue_id].minimum_neg_inc := f$queue_attribute_value
                (pvt [p$minimum_size_negative_increme], queues [queue_id].
                minimum_neg_inc, gpql_default [queue_id].minimum_neg_inc);
          queues [queue_id].minimum_neg_inc_pc := f$queue_attribute_value
                (pvt [p$minimum_size_negative_inc_pc], queues [queue_id].
                minimum_neg_inc_pc, gpql_default [queue_id].minimum_neg_inc_pc);
          queues [queue_id].minimum_pos_inc := f$queue_attribute_value
                (pvt [p$minimum_size_positive_increme], queues [queue_id].
                minimum_pos_inc, gpql_default [queue_id].minimum_pos_inc);
          queues [queue_id].minimum_pos_inc_pc := f$queue_attribute_value
                (pvt [p$minimum_size_positive_inc_pc], queues [queue_id].
                minimum_pos_inc_pc, gpql_default [queue_id].minimum_pos_inc_pc);

          queues [queue_id].maximum_nominal := f$queue_attribute_value
                (pvt [p$maximum_size], queues [queue_id].maximum_nominal,
                gpql_default [queue_id].maximum_nominal);
          queues [queue_id].maximum_min := f$queue_attribute_value
                (pvt [p$maximum_size_min], queues [queue_id].maximum_min, gpql_default [queue_id].
                maximum_min);
          queues [queue_id].maximum_max := f$queue_attribute_value
                (pvt [p$maximum_size_max], queues [queue_id].maximum_max, gpql_default [queue_id].
                maximum_max);
          queues [queue_id].maximum_neg_inc := f$queue_attribute_value
                (pvt [p$maximum_size_negative_increme], queues [queue_id].
                maximum_neg_inc, gpql_default [queue_id].maximum_neg_inc);
          queues [queue_id].maximum_neg_inc_pc := f$queue_attribute_value
                (pvt [p$maximum_size_negative_inc_pc], queues [queue_id].
                maximum_neg_inc_pc, gpql_default [queue_id].maximum_neg_inc_pc);
          queues [queue_id].maximum_pos_inc := f$queue_attribute_value
                (pvt [p$maximum_size_positive_increme], queues [queue_id].
                maximum_pos_inc, gpql_default [queue_id].maximum_pos_inc);
          queues [queue_id].maximum_pos_inc_pc := f$queue_attribute_value
                (pvt [p$maximum_size_positive_inc_pc], queues [queue_id].
                maximum_pos_inc_pc, gpql_default [queue_id].maximum_pos_inc_pc);

          IF pvt [p$age_cycles].specified THEN
            IF pvt [p$age_cycles].value^.kind <> clc$keyword THEN
              queues [queue_id].age_cycles := evaluated_age_cycles;
            ELSE
              queues [queue_id].age_cycles := gpql_default [queue_id].age_cycles;
            IFEND;
          IFEND;
        IFEND;
      FOREND;

      mmp$store_manage_memory_data_r3 (pvt [p$reset_dynamic_aging_attribute].value^.boolean_value.value,
            queues, ma_values, status);

    PROCEND change_shared_queue_att_dynamic;
?? OLDTITLE ??
?? NEWTITLE := 'evaluate_age_cycles', EJECT ??

{ PURPOSE:
{   This request evaluates the SCL age_cycles value to MMT$PAGE_QUEUE_AGE_CYCLES.
{
{ NOTE:
{   The KEYWORD "DEFAULT" cannot be evaluated at this point as default does not
{   be the same for all specified queues!

    PROCEDURE evaluate_age_cycles
      (    data_value_p: ^clt$data_value;
       VAR evaluated_age_cycles: mmt$page_queue_age_cycles;
       VAR status: ost$status);

      VAR
        age_cycle_value: integer,
        age_cycle_increment: integer,
        element_p: ^clt$data_value,
        list_node_p: ^clt$data_value;


      CASE data_value_p^.kind OF
      = clc$keyword =
        IF data_value_p^.keyword_value = 'DEFAULT' THEN
          { We don't do anything. DEFAULT is evaluated for each queue individually.
          ;
        ELSEIF data_value_p^.keyword_value = 'ALL' THEN
          evaluated_age_cycles := -$mmt$page_queue_age_cycles [];
        ELSE
          osp$set_status_abnormal ('CL', cle$unknown_keyword, data_value_p^.keyword_value, status);
          RETURN; {----->
        IFEND;

      = clc$list =
        evaluated_age_cycles := $mmt$page_queue_age_cycles [];
        list_node_p := data_value_p;
        WHILE (list_node_p <> NIL) AND (list_node_p^.kind = clc$list) DO
          element_p := list_node_p^.element_value;

          IF (element_p <> NIL) AND (element_p^.kind = clc$integer) THEN
            add_age_cycle (element_p^.integer_value.value, evaluated_age_cycles, status);
            IF NOT status.normal THEN
              RETURN; {----->
            IFEND;
          IFEND;

          list_node_p := list_node_p^.link;
        WHILEND;

      = clc$record =
        evaluated_age_cycles := $mmt$page_queue_age_cycles [];

        IF (data_value_p^.field_values = NIL)
{     } OR (UPPERBOUND (data_value_p^.field_values^) <> 2)
{     } OR (data_value_p^.field_values^ [1].value = NIL)
{     } OR (data_value_p^.field_values^ [2].value = NIL) THEN

          osp$set_status_condition (cle$field_requirements_mismatch, status);
          RETURN; {----->

        ELSE
          age_cycle_value := data_value_p^.field_values^ [1].value^.integer_value.value;
          age_cycle_increment := data_value_p^.field_values^ [2].value^.integer_value.value;

          REPEAT
            add_age_cycle (age_cycle_value, evaluated_age_cycles, status);
            IF NOT status.normal THEN
              RETURN; {----->
            IFEND;

            age_cycle_value := age_cycle_value + age_cycle_increment;
          UNTIL age_cycle_value > c$page_queue_age_cycle_max;
        IFEND;
      CASEND;

      IF evaluated_age_cycles = $mmt$page_queue_age_cycles [] THEN
        { osp$set_status_abnormal
      IFEND;

    PROCEND evaluate_age_cycles;
?? OLDTITLE ??
?? NEWTITLE := '[inline] F$QUEUE_ATTRIBUTE_VALUE', EJECT ??

    FUNCTION [INLINE] f$queue_attribute_value
      (    parameter_value: clt$parameter_value;
           original: integer;
           default: integer): integer;

      IF parameter_value.specified THEN
        IF parameter_value.value^.kind = clc$integer THEN
          f$queue_attribute_value := parameter_value.value^.integer_value.value;
        ELSE
          f$queue_attribute_value := default;
        IFEND;
      ELSE
        f$queue_attribute_value := original;
      IFEND;

    FUNCEND f$queue_attribute_value;
?? OLDTITLE ??
?? EJECT ??
    status.normal := TRUE;
    mmp$fetch_dynamic_aging_enab_r3 (dynamic_aging_enabled);
    IF dynamic_aging_enabled OR (c$change_shared_queue_attrib IN
          mmv$debug_options.force_dynamic_aging_attributes) THEN
      change_shared_queue_att_dynamic (parameter_list, status);
    ELSE
      change_shared_queue_att_normal (parameter_list, status);
    IFEND;

  PROCEND change_shared_queue_attribute;
?? OLDTITLE ??
?? NEWTITLE := 'display_memory_attribute', EJECT ??

{ PURPOSE:
{   This procedure processes the DISPLAY_MEMORY_ATTRIBUTE Command.  The command provides the capability to
{   display various memory attributes.  These are various variables defined in mainframe wired modules of
{   EXEC's memory management.  A Ring 3 helper routine is called to fetch all of the data that can be
{   displayed.  The command is then cracked and a display is built to display the requested data.

  PROCEDURE display_memory_attribute
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{copyc mmd$mmu_display_memory_attrib
{copyc mmd$mmu_display_memory_attrib_d
?? PUSH (LISTEXT := ON) ??
*copy clp$new_page_procedure
*copy clv$display_variables
?? POP ??

    TYPE
      t$line = record
        case 0 .. 2 of
        = 0 =
          data: string (c$max_line_size),
        = 1 =
          space_a_1: string (7),
          name_part: string (4),
          space_a_2: string (28),
          value_part: string (5),
          space_a_3: string (6),
          units_part: string (5),
        = 2 =
          space_b_1: string (1),
          mmu_name_part: string (31),
          space_b_2: string (2),
          mmu_value_part: string (10),
          space_b_3: string (3),
          mmu_units_part: string (13),
        casend,
      recend;

    VAR
      display_control: clt$display_control,
      dynamic_aging_enabled: boolean,
      gpql_default: mmt$mmu_gpql_default,
      ignore_status: ost$status,
      line: t$line,
      ma_default: mmt$mmu_ma_default,
      ma_index: mmt$mmu_memory_attributes,
      ma_values: mmt$mmu_ma_values,
      queues: mmt$global_page_queue_list,
      selected_attributes: t$memory_attributes;

?? 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;
?? OLDTITLE ??
?? NEWTITLE := 'put_subtitle', EJECT ??

{  PURPOSE:
{    The procedure clp$new_page_procedure which is copied via *copyc from a common deck expects to call a
{    local procedure to put out subtitles. Since we do not need subtitles this proc is a dummy.

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

    PROCEND put_subtitle;
?? OLDTITLE ??
?? NEWTITLE := 'get_selected_attributes', EJECT ??

    PROCEDURE get_selected_attributes
      (    value_p: ^clt$data_value;
           dynamic_attributes_available: boolean;
       VAR selected_attributes: t$memory_attributes);

      VAR
        list_p: ^clt$data_value,
        ma_index: mmt$mmu_memory_attributes,
        option_p: ^clt$data_value;

      selected_attributes := $t$memory_attributes [];
      list_p := value_p;

    /flag_selected_attributes/
      WHILE list_p <> NIL DO
        option_p := list_p^.element_value;
        list_p := list_p^.link;

        IF option_p^.keyword_value = 'ALL' THEN
          IF dynamic_attributes_available THEN
            selected_attributes := -$t$memory_attributes [];
          ELSE
            selected_attributes := -$t$memory_attributes [] - v$dynamic_memory_attributes;
          IFEND;

          EXIT /flag_selected_attributes/ {----->
        IFEND;
        FOR ma_index := LOWERBOUND (v$mmu_info_ma) TO UPPERBOUND (v$mmu_info_ma) DO
          IF option_p^.keyword_value = v$mmu_info_ma [ma_index].name THEN
            selected_attributes := selected_attributes + $t$memory_attributes [v$mmu_info_ma [ma_index].
                  index];
            CYCLE /flag_selected_attributes/; {----->
          IFEND;
        FOREND;
      WHILEND /flag_selected_attributes/;

    PROCEND get_selected_attributes;
?? OLDTITLE ??
?? NEWTITLE := 'init_dynamic', EJECT ??

    PROCEDURE init_dynamic
      (    parameter_list: clt$parameter_list;
       VAR selected_attributes: t$memory_attributes;
       VAR display_control: clt$display_control;
       VAR status: ost$status);

*copyc mmd$mmu_display_memory_attrib_d

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

      get_selected_attributes (pvt [p$display_option].value, TRUE {=dynamic}, selected_attributes);

      open_output_file (pvt [p$output].value, display_control, status);

    PROCEND init_dynamic;
?? OLDTITLE ??
?? NEWTITLE := 'init_normal', EJECT ??

    PROCEDURE init_normal
      (    parameter_list: clt$parameter_list;
       VAR selected_attributes: t$memory_attributes;
       VAR display_control: clt$display_control;
       VAR status: ost$status);

*copyc mmd$mmu_display_memory_attrib

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

      get_selected_attributes (pvt [p$display_option].value, FALSE {=standard}, selected_attributes);

      open_output_file (pvt [p$output].value, display_control, status);

    PROCEND init_normal;
?? OLDTITLE ??
?? NEWTITLE := 'open_output_file', EJECT ??

    PROCEDURE open_output_file
      (    file_value_p: ^clt$data_value;
       VAR display_control: clt$display_control;
       VAR status: ost$status);

      VAR
        ring_attributes: amt$ring_attributes;

      display_control := clv$nil_display_control;
      clv$titles_built := FALSE;
      clv$command_name := 'display_memory_attribute';
      ring_attributes.r1 := #RING (^ring_attributes);
      ring_attributes.r2 := #RING (^ring_attributes);
      ring_attributes.r3 := #RING (^ring_attributes);
      clp$open_display_reference (file_value_p^.file_value^, ^clp$new_page_procedure, fsc$list,
            ring_attributes, display_control, status);

    PROCEND open_output_file;
?? OLDTITLE ??
?? EJECT ??
    status.normal := TRUE;
    mmp$fetch_dynamic_aging_enab_r3 (dynamic_aging_enabled);
    IF dynamic_aging_enabled OR (c$display_memory_attributes IN
          mmv$debug_options.force_dynamic_aging_attributes) THEN
      init_dynamic (parameter_list, selected_attributes, display_control, status);
    ELSE
      init_normal (parameter_list, selected_attributes, display_control, status);
    IFEND;
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    osp$establish_block_exit_hndlr (^abort_handler);

    mmp$fetch_manage_memory_data_r3 (queues, ma_values, gpql_default, ma_default);

    IF (display_control.page_format = amc$burstable_form) OR
          (display_control.page_format = amc$non_burstable_form) THEN
      clp$new_display_page (display_control, ignore_status);
      clp$new_display_line (display_control, 2, ignore_status);
    IFEND;


    { Print a Header line.
    line.data := ' ';
    line.name_part := 'NAME';
    line.value_part := 'VALUE';
    line.units_part := 'UNITS';
    clp$put_display (display_control, line.data, clc$no_trim, ignore_status);

    { Examine each entry in v$mmu_info_ma which contains the name, units, and index which are used to
    { build a line of display.  If the indexed entry is included in the selected_attributes set, then
    { the line of display is issued.

    FOR ma_index := LOWERBOUND (v$mmu_info_ma) TO UPPERBOUND (v$mmu_info_ma) DO
      IF v$mmu_info_ma [ma_index].index IN selected_attributes THEN
        line.data := ' ';
        line.mmu_name_part := v$mmu_info_ma [ma_index].name;
        clp$convert_integer_to_rjstring (ma_values [v$mmu_info_ma [ma_index].index],
              10, FALSE, ' ', line.mmu_value_part, ignore_status);
        line.mmu_units_part := v$mmu_info_ma [ma_index].units_name;
        clp$put_display (display_control, line.data, clc$no_trim, ignore_status);
      IFEND;
    FOREND;

    clp$close_display (display_control, ignore_status);
    osp$disestablish_cond_handler;

  PROCEND display_memory_attribute;
?? OLDTITLE ??
?? NEWTITLE := 'display_shared_queue_attribute', EJECT ??

{ PURPOSE:
{   This procedure processes the DISPLAY_SHARED_QUEUE_ATTRIBUTE Command.  The command provides the capability
{   to display the attributes of the shared queues which affect the rate of aging and the number of pages in
{   each of the shared queues.  The attributes are in the global page queue list headers which are found in
{   the mainframe wired modules of EXEC's memory management.  A Ring 3 helper routine is called to fetch all
{   of the data that can be displayed.  The command is then cracked and a display is built to display the
{   requested data.

  PROCEDURE display_shared_queue_attribute
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

?? PUSH (LISTEXT := ON) ??
*copy clp$new_page_procedure
*copy clv$display_variables
?? POP ??

    CONST
      c$max_line_size = 80;

    VAR
      display_control: clt$display_control,
      dynamic_aging_enabled: boolean;

?? 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;
?? OLDTITLE ??
?? NEWTITLE := 'add_queue_name', EJECT ??

    PROCEDURE add_queue_name
      (    queue_id: mmt$page_frame_queue_id;
       VAR str: string (c$max_line_size));

      TYPE
        t$queue_part = record
          case 0 .. 2 of
          = 0 =
            data: string (21),
          = 1 =
            filler_1: string (1),
            queue: string (20),
          = 2 =
            filler_2: string (1),
            site_name: string (5),
            site_number: string (2),
          casend,
        recend;

      VAR
        ignore_status: ost$status,
        name: t$queue_part;

      name.data := '';
      IF queue_id < mmc$pq_shared_first_site THEN
        name.queue := v$dissqa_data [queue_id];
      ELSE
        name.queue := v$dissqa_data [mmc$pq_shared_first_site];
        clp$convert_integer_to_rjstring ((queue_id - mmc$pq_shared_last_sys), 10, FALSE, '0',
              name.site_number, ignore_status);
      IFEND;

      str := name.data;

    PROCEND add_queue_name;
?? OLDTITLE ??
?? NEWTITLE := 'put_subtitle', EJECT ??

{  PURPOSE:
{    The procedure clp$new_page_procedure which is copied via *copyc from a common deck expects to call a
{    local procedure to put out subtitles. Since we do not need subtitles this proc is a dummy.

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

    PROCEND put_subtitle;
?? OLDTITLE ??
?? EJECT ??
?? NEWTITLE := 'display_shared_queue_att_dynam', EJECT ??

    PROCEDURE display_shared_queue_att_dynam
      (    parameter_list: clt$parameter_list;
       VAR status: ost$status);

*copyc mmd$mmu_display_shared_q_att_d

      TYPE
        t$display_kind = (c$age_interval_ceiling, c$minimim_size, c$maximim_size, c$queue_cyclic_age),
        t$display_kinds = set of t$display_kind;

      TYPE
        t$line = record
          case 0 .. 4 of
          = 0 = { complete string
            data: string (c$max_line_size),
          = 1 = { queue cyclic age
            queue_name_1: string (20),
            queue_cyclic_age: string (5),
            queue_age_interval: string (6),
            encrease_min_enable_dynamic_age: string (12),
            space_a_1: string (5),
            age_cycles: string (32),
          = 2 = { age interval ceiling
            queue_name_2: string (20),
            age_interval_actual_modified: string (4),
            age_interval_actual_unmodified: string (5),
            age_interval_nominal_modified: string (5),
            age_interval_nominal_unmodified: string (5),
            age_interval_modified_max: string (5),
            age_interval_unmodified_max: string (5),
            age_interval_modified_min: string (5),
            age_interval_unmodified_min: string (5),
            age_interval_neg_inc_modified: string (5),
            age_interval_neg_inc_unmodified: string (5),
            age_interval_pos_inc_modified: string (5),
            age_interval_pos_inc_unmodified: string (5),
          = 3 = {minimum_size
            queue_name_3: string (20),
            minimum_actual: string (7),
            minimum_nominal: string (8),
            minimum_min: string (8),
            minimum_max: string (8),
            minimum_neg_inc: string (8),
            minimum_neg_inc_pc: string (6),
            minimum_pos_inc: string (8),
            minimum_pos_inc_pc: string (6),
          = 4 = {maximum_size
            queue_name_4: string (20),
            maximum_actual: string (7),
            maximum_actual_cycle: string (7),
            maximum_nominal: string (7),
            maximum_min: string (7),
            maximum_max: string (7),
            maximum_neg_inc: string (7),
            maximum_neg_inc_pc: string (5),
            maximum_pos_inc: string (7),
            maximum_pos_inc_pc: string (5),
          casend,
        recend;

      CONST
        c$cyclic_age_1 = '                                    Encrease              Age Cycles',
        c$cyclic_age_2 = '                      Cyclic Age    Min Enable           1         2         3',
        c$cyclic_age_3 = '     QUEUE            Age Interval Dynamic Age  12345678901234567890123456789012',

        c$age_interv_1 = '                                     Age Interval Ceiling',
        c$age_interv_2 = '                     -Actual-- -Nominal- ---Max--- ---Min--- -Neg Inc- -Pos Inc-',
        c$age_interv_3 = '     QUEUE           Mod Unmod Mod Unmod Mod Unmod Mod Unmod Mod Unmod Mod Unmod',

        c$minimum_1 = '                                        Minimum',
        c$minimum_2 = '     QUEUE           Actual Nominal     Min     Max    Neg Incr %    Pos Incr %',
        c$maximum_1 = '                                        Maximum',
        c$maximum_2 = '     QUEUE           Actual  Cycle Nominal   Min    Max  Neg Incr %  Pos Incr %';

      VAR
        age_cycle: mmt$page_queue_age_cycle,
        display_kinds: t$display_kinds,
        first_queue_id: mmt$page_frame_queue_id,
        gpql_default: mmt$mmu_gpql_default,
        ignore_status: ost$status,
        last_queue_id: mmt$page_frame_queue_id,
        line: t$line,
        ma_default: mmt$mmu_ma_default,
        ma_values: mmt$mmu_ma_values,
        queue_id: mmt$page_frame_queue_id,
        queues: mmt$global_page_queue_list,
        ring_attributes: amt$ring_attributes,
        site_active_queue_count: 0 .. mmc$pq_shared_num_sites,
        value_p: ^clt$data_value;

      status.normal := TRUE;
      clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;

      mmp$fetch_manage_memory_data_r3 (queues, ma_values, gpql_default, ma_default);
      mmp$fetch_site_active_q_cnt_r3 (site_active_queue_count);

      display_control := clv$nil_display_control;
      clv$titles_built := FALSE;
      clv$command_name := 'display_shared_queue_attribute';
      ring_attributes.r1 := #RING (^ring_attributes);
      ring_attributes.r2 := #RING (^ring_attributes);
      ring_attributes.r3 := #RING (^ring_attributes);
      clp$open_display_reference (pvt [p$output].value^.file_value^, ^clp$new_page_procedure, fsc$list,
            ring_attributes, display_control, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
      osp$establish_block_exit_hndlr (^abort_handler);

      IF (display_control.page_format = amc$burstable_form) OR
            (display_control.page_format = amc$non_burstable_form) THEN
        clp$new_display_page (display_control, ignore_status);
        clp$new_display_line (display_control, 2, ignore_status);
      IFEND;

{Evaluate Queues
      IF pvt [p$queue].value^.kind = clc$keyword THEN { ALL is the only keyword allowed. }
        first_queue_id := mmc$pq_shared_first;
        last_queue_id := mmc$pq_shared_last_site;
      ELSE
        first_queue_id := mmc$pq_shared_first_site;
        last_queue_id := mmc$pq_shared_last_sys;
        value_p := pvt [p$queue].value;
        WHILE value_p <> NIL DO
          IF value_p^.element_value^.keyword_value = 'SYSTEM' THEN
            first_queue_id := mmc$pq_shared_first;
          ELSEIF value_p^.element_value^.keyword_value = 'ACTIVE_SITE_DEFINED' THEN
            last_queue_id := mmc$pq_shared_first_site + site_active_queue_count - 1;
          IFEND;
          value_p := value_p^.link;
        WHILEND;
      IFEND;

{Evaluate Display Option
      display_kinds := $t$display_kinds [];
      value_p := pvt [p$display_option].value;
      WHILE value_p <> NIL DO
        IF value_p^.element_value^.keyword_value = 'ALL' THEN
          display_kinds := -$t$display_kinds [];
        ELSEIF value_p^.element_value^.keyword_value = 'AGE_INTERVAL_CEILING' THEN
          display_kinds := display_kinds + $t$display_kinds [c$age_interval_ceiling];
        ELSEIF value_p^.element_value^.keyword_value = 'MINIMIM_SIZE' THEN
          display_kinds := display_kinds + $t$display_kinds [c$minimim_size];
        ELSEIF value_p^.element_value^.keyword_value = 'MAXIMIM_SIZE' THEN
          display_kinds := display_kinds + $t$display_kinds [c$maximim_size];
        ELSEIF value_p^.element_value^.keyword_value = 'QUEUE_CYCLIC_AGE' THEN
          display_kinds := display_kinds + $t$display_kinds [c$queue_cyclic_age];
        IFEND;
        value_p := value_p^.link;
      WHILEND;

      IF (first_queue_id = mmc$pq_shared_first_site) AND (site_active_queue_count = 0) THEN
        line.data := ' No site defined shared queues are active.';
        clp$put_display (display_control, line.data, clc$no_trim, ignore_status);
      ELSE
        IF c$queue_cyclic_age IN display_kinds THEN
          clp$put_display (display_control, c$cyclic_age_1, clc$no_trim, ignore_status);
          clp$put_display (display_control, c$cyclic_age_2, clc$no_trim, ignore_status);
          clp$put_display (display_control, c$cyclic_age_3, clc$no_trim, ignore_status);

          FOR queue_id := first_queue_id TO last_queue_id DO
            add_queue_name (queue_id, line.data);
            clp$convert_integer_to_rjstring (queues [queue_id].queue_cyclic_age, 10, FALSE, ' ',
                  line.queue_cyclic_age, ignore_status);
            clp$convert_integer_to_rjstring (queues [queue_id].queue_age_interval, 10, FALSE, ' ',
                  line.queue_age_interval, ignore_status);
            clp$convert_integer_to_rjstring (queues [queue_id].encrease_min_enable_dynamic_age, 10, FALSE,
                  ' ', line.encrease_min_enable_dynamic_age, ignore_status);

            FOR age_cycle := mmc$page_queue_age_cycle_min TO mmc$page_queue_age_cycle_max DO
              IF age_cycle IN queues [queue_id].age_cycles THEN
                line.age_cycles (age_cycle + 1) := 'X';
              IFEND;
            FOREND;
            clp$put_display (display_control, line.data, clc$trim, ignore_status);
          FOREND;
        IFEND;

        IF c$age_interval_ceiling IN display_kinds THEN
          clp$put_display (display_control, c$age_interv_1, clc$no_trim, ignore_status);
          clp$put_display (display_control, c$age_interv_2, clc$no_trim, ignore_status);
          clp$put_display (display_control, c$age_interv_3, clc$no_trim, ignore_status);

          FOR queue_id := first_queue_id TO last_queue_id DO
            add_queue_name (queue_id, line.data);

            clp$convert_integer_to_rjstring (queues [queue_id].age_interval_actual_modified, 10, FALSE, ' ',
                  line.age_interval_actual_modified, ignore_status);
            clp$convert_integer_to_rjstring (queues [queue_id].age_interval_actual_unmodified, 10, FALSE, ' ',
                  line.age_interval_actual_unmodified, ignore_status);
            clp$convert_integer_to_rjstring (queues [queue_id].age_interval_nominal_modified, 10, FALSE, ' ',
                  line.age_interval_nominal_modified, ignore_status);
            clp$convert_integer_to_rjstring (queues [queue_id].age_interval_nominal_unmodified, 10, FALSE,
                  ' ', line.age_interval_nominal_unmodified, ignore_status);
            clp$convert_integer_to_rjstring (queues [queue_id].age_interval_modified_max, 10, FALSE, ' ',
                  line.age_interval_modified_max, ignore_status);
            clp$convert_integer_to_rjstring (queues [queue_id].age_interval_unmodified_max, 10, FALSE, ' ',
                  line.age_interval_unmodified_max, ignore_status);
            clp$convert_integer_to_rjstring (queues [queue_id].age_interval_modified_min, 10, FALSE, ' ',
                  line.age_interval_modified_min, ignore_status);
            clp$convert_integer_to_rjstring (queues [queue_id].age_interval_unmodified_min, 10, FALSE, ' ',
                  line.age_interval_unmodified_min, ignore_status);
            clp$convert_integer_to_rjstring (queues [queue_id].age_interval_neg_inc_modified, 10, FALSE, ' ',
                  line.age_interval_neg_inc_modified, ignore_status);
            clp$convert_integer_to_rjstring (queues [queue_id].age_interval_neg_inc_unmodified, 10, FALSE,
                  ' ', line.age_interval_neg_inc_unmodified, ignore_status);
            clp$convert_integer_to_rjstring (queues [queue_id].age_interval_pos_inc_modified, 10, FALSE, ' ',
                  line.age_interval_pos_inc_modified, ignore_status);
            clp$convert_integer_to_rjstring (queues [queue_id].age_interval_pos_inc_unmodified, 10, FALSE,
                  ' ', line.age_interval_pos_inc_unmodified, ignore_status);

            clp$put_display (display_control, line.data, clc$trim, ignore_status);
          FOREND;
        IFEND;

        IF c$minimim_size IN display_kinds THEN
          clp$put_display (display_control, c$minimum_1, clc$no_trim, ignore_status);
          clp$put_display (display_control, c$minimum_2, clc$no_trim, ignore_status);

          FOR queue_id := first_queue_id TO last_queue_id DO
            add_queue_name (queue_id, line.data);

            clp$convert_integer_to_rjstring (queues [queue_id].minimum_actual, 10, FALSE, ' ',
                  line.minimum_actual, ignore_status);
            clp$convert_integer_to_rjstring (queues [queue_id].minimum_nominal, 10, FALSE, ' ',
                  line.minimum_nominal, ignore_status);
            clp$convert_integer_to_rjstring (queues [queue_id].minimum_min, 10, FALSE, ' ', line.minimum_min,
                  ignore_status);
            clp$convert_integer_to_rjstring (queues [queue_id].minimum_max, 10, FALSE, ' ', line.minimum_max,
                  ignore_status);
            clp$convert_integer_to_rjstring (queues [queue_id].minimum_neg_inc, 10, FALSE, ' ',
                  line.minimum_neg_inc, ignore_status);
            clp$convert_integer_to_rjstring (queues [queue_id].minimum_neg_inc_pc, 10, FALSE, ' ',
                  line.minimum_neg_inc_pc, ignore_status);
            clp$convert_integer_to_rjstring (queues [queue_id].minimum_pos_inc, 10, FALSE, ' ',
                  line.minimum_pos_inc, ignore_status);
            clp$convert_integer_to_rjstring (queues [queue_id].minimum_pos_inc_pc, 10, FALSE, ' ',
                  line.minimum_pos_inc_pc, ignore_status);

            clp$put_display (display_control, line.data, clc$trim, ignore_status);
          FOREND;
        IFEND;

        IF c$maximim_size IN display_kinds THEN
          clp$put_display (display_control, c$maximum_1, clc$no_trim, ignore_status);
          clp$put_display (display_control, c$maximum_2, clc$no_trim, ignore_status);

          FOR queue_id := first_queue_id TO last_queue_id DO
            add_queue_name (queue_id, line.data);

            clp$convert_integer_to_rjstring (queues [queue_id].maximum_actual, 10, FALSE, ' ',
                  line.maximum_actual, ignore_status);
            clp$convert_integer_to_rjstring (queues [queue_id].maximum_actual_cycle, 10, FALSE, ' ',
                  line.maximum_actual_cycle, ignore_status);
            clp$convert_integer_to_rjstring (queues [queue_id].maximum_nominal, 10, FALSE, ' ',
                  line.maximum_nominal, ignore_status);
            clp$convert_integer_to_rjstring (queues [queue_id].maximum_min, 10, FALSE, ' ', line.maximum_min,
                  ignore_status);
            clp$convert_integer_to_rjstring (queues [queue_id].maximum_max, 10, FALSE, ' ', line.maximum_max,
                  ignore_status);
            clp$convert_integer_to_rjstring (queues [queue_id].maximum_neg_inc, 10, FALSE, ' ',
                  line.maximum_neg_inc, ignore_status);
            clp$convert_integer_to_rjstring (queues [queue_id].maximum_neg_inc_pc, 10, FALSE, ' ',
                  line.maximum_neg_inc_pc, ignore_status);
            clp$convert_integer_to_rjstring (queues [queue_id].maximum_pos_inc, 10, FALSE, ' ',
                  line.maximum_pos_inc, ignore_status);
            clp$convert_integer_to_rjstring (queues [queue_id].maximum_pos_inc_pc, 10, FALSE, ' ',
                  line.maximum_pos_inc_pc, ignore_status);

            clp$put_display (display_control, line.data, clc$trim, ignore_status);
          FOREND;
        IFEND;
      IFEND;

      clp$close_display (display_control, ignore_status);
      osp$disestablish_cond_handler;

    PROCEND display_shared_queue_att_dynam;
?? OLDTITLE ??
?? NEWTITLE := 'display_shared_queue_att_normal', EJECT ??

    PROCEDURE display_shared_queue_att_normal
      (    parameter_list: clt$parameter_list;
       VAR status: ost$status);

*copyc mmd$mmu_display_shared_q_attrib

      TYPE
        t$line = record
          case 0 .. 4 of
          = 0 =
            data: string (c$max_line_size),
          = 1 =
            space_a_1: string (28),
            age_interval_name: string (12),
            space_a_2: string (5),
            nominal_range_name: string (20),
          = 2 =
            space_b_1: string (5),
            queue_name: string (5),
            space_b_2: string (20),
            ceiling_name: string (7),
            space_b_3: string (9),
            min_max_name: string (16),
          = 3 =
            space_c_1: string (29),
            mod_unmod_name: string (10),
          = 4 =
            space_d_1: string (1),
            queue_part: t$queue_part,
            space_d_2: string (4),
            aic_part_mod: string (6),
            space_d_3: string (1),
            aic_part_unmod: string (6),
            space_d_4: string (1),
            min_part: string (12),
            max_part: string (12),
          casend,
        recend,

        t$queue_part = record
          case 0 .. 1 of
          = 0 =
            data: string (20),
          = 1 =
            site_name: string (5),
            site_number: string (2),
          casend,
        recend;

      VAR
        display_control: clt$display_control,
        first_queue_id: mmt$page_frame_queue_id,
        gpql_default: mmt$mmu_gpql_default,
        ignore_status: ost$status,
        last_queue_id: mmt$page_frame_queue_id,
        line: t$line,
        ma_default: mmt$mmu_ma_default,
        ma_values: mmt$mmu_ma_values,
        queue_id: mmt$page_frame_queue_id,
        queue_list: ^clt$data_value,
        queues: mmt$global_page_queue_list,
        ring_attributes: amt$ring_attributes,
        site_active_queue_count: 0 .. mmc$pq_shared_num_sites;

      status.normal := TRUE;
      clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;

      mmp$fetch_manage_memory_data_r3 (queues, ma_values, gpql_default, ma_default);
      mmp$fetch_site_active_q_cnt_r3 (site_active_queue_count);

      display_control := clv$nil_display_control;
      clv$titles_built := FALSE;
      clv$command_name := 'display_shared_queue_attribute';
      ring_attributes.r1 := #RING (^ring_attributes);
      ring_attributes.r2 := #RING (^ring_attributes);
      ring_attributes.r3 := #RING (^ring_attributes);
      clp$open_display_reference (pvt [p$output].value^.file_value^, ^clp$new_page_procedure, fsc$list,
            ring_attributes, display_control, status);
      IF NOT status.normal THEN
        RETURN; {----->
      IFEND;
      osp$establish_block_exit_hndlr (^abort_handler);

      IF (display_control.page_format = amc$burstable_form) OR
            (display_control.page_format = amc$non_burstable_form) THEN
        clp$new_display_page (display_control, ignore_status);
        clp$new_display_line (display_control, 2, ignore_status);
      IFEND;

      IF pvt [p$queue].value^.kind = clc$keyword THEN { ALL is the only keyword allowed. }
        first_queue_id := mmc$pq_shared_first;
        last_queue_id := mmc$pq_shared_last_site;
      ELSE
        first_queue_id := mmc$pq_shared_first_site;
        last_queue_id := mmc$pq_shared_last_sys;
        queue_list := pvt [p$queue].value;
        WHILE queue_list <> NIL DO
          IF queue_list^.element_value^.keyword_value = 'SYSTEM' THEN
            first_queue_id := mmc$pq_shared_first;
          ELSEIF queue_list^.element_value^.keyword_value = 'ACTIVE_SITE_DEFINED' THEN
            last_queue_id := mmc$pq_shared_first_site + site_active_queue_count - 1;
          IFEND;
          queue_list := queue_list^.link;
        WHILEND;
      IFEND;

      IF (first_queue_id = mmc$pq_shared_first_site) AND (site_active_queue_count = 0) THEN
        line.data := ' No site defined shared queues are active.';
        clp$put_display (display_control, line.data, clc$no_trim, ignore_status);
      ELSE
        line.data := ' ';
        line.age_interval_name := 'AGE INTERVAL';
        line.nominal_range_name := 'NOMINAL RANGE(pages)';
        clp$put_display (display_control, line.data, clc$no_trim, ignore_status);
        line.data := ' ';
        line.queue_name := 'QUEUE';
        line.ceiling_name := 'CEILING';
        line.min_max_name := 'MINIMUM..MAXIMUM';
        clp$put_display (display_control, line.data, clc$no_trim, ignore_status);

        line.data := ' ';
        line.mod_unmod_name := 'MOD  UNMOD';
        clp$put_display (display_control, line.data, clc$no_trim, ignore_status);

        FOR queue_id := first_queue_id TO last_queue_id DO
          line.data := ' ';
          IF queue_id < mmc$pq_shared_first_site THEN
            line.queue_part.data := v$dissqa_data [queue_id];
          ELSE
            line.queue_part.data := v$dissqa_data [mmc$pq_shared_first_site];
            clp$convert_integer_to_rjstring ((queue_id - mmc$pq_shared_last_sys), 10, FALSE, '0',
                  line.queue_part.site_number, ignore_status);
          IFEND;
          clp$convert_integer_to_rjstring (queues [queue_id].age_interval_actual_modified, 10, FALSE, ' ',
                line.aic_part_mod, ignore_status);
          clp$convert_integer_to_rjstring (queues [queue_id].age_interval_actual_unmodified, 10, FALSE, ' ',
                line.aic_part_unmod, ignore_status);
          clp$convert_integer_to_rjstring (queues [queue_id].minimum_actual, 10, FALSE, ' ', line.min_part,
                ignore_status);
          clp$convert_integer_to_rjstring (queues [queue_id].maximum_actual, 10, FALSE, ' ', line.max_part,
                ignore_status);
          clp$put_display (display_control, line.data, clc$no_trim, ignore_status);
        FOREND;
      IFEND;

      clp$close_display (display_control, ignore_status);
      osp$disestablish_cond_handler;

    PROCEND display_shared_queue_att_normal;
?? OLDTITLE ??
?? EJECT ??

    mmp$fetch_dynamic_aging_enab_r3 (dynamic_aging_enabled);
    IF dynamic_aging_enabled OR (c$display_shared_queue_attrib IN
          mmv$debug_options.force_dynamic_aging_attributes) THEN
      display_shared_queue_att_dynam (parameter_list, status);
    ELSE
      display_shared_queue_att_normal (parameter_list, status);
    IFEND;

  PROCEND display_shared_queue_attribute;
?? OLDTITLE ??
?? NEWTITLE := 'display_shared_queue_cycles', EJECT ??

  PROCEDURE display_shared_queue_cycles
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

*copyc mmd$mmu_display_shared_q_cycles
?? PUSH (LISTEXT := ON) ??
*copy clp$new_page_procedure
*copy clv$display_variables
?? POP ??

    TYPE
      t$line = record
        case 0 .. 3 of
        = 0 =
          data: string (c$max_line_size),
        = 1 =
          space_a_1: string (23),
          defined_age_cycles_name: string (32),
        = 2 =
          space_b_1: string (5),
          queue_name: string (5),
          space_b_2: string (13),
          age_cycle_title: string (32),
        = 3 =
          space_c_1: string (1),
          queue_part: t$queue_part,
          space_c_2: string (2),
          age_cycles: string (32),
        casend,
      recend,

      t$queue_part = record
        case 0 .. 1 of
        = 0 =
          data: string (20),
        = 1 =
          site_name: string (5),
          site_number: string (2),
        casend,
      recend;

    VAR
      display_control: clt$display_control,
      age_cycle: mmt$page_queue_age_cycle,
      first_queue_id: mmt$page_frame_queue_id,
      gpql_default: mmt$mmu_gpql_default,
      ignore_status: ost$status,
      last_queue_id: mmt$page_frame_queue_id,
      line: t$line,
      ma_default: mmt$mmu_ma_default,
      ma_values: mmt$mmu_ma_values,
      queue_id: mmt$page_frame_queue_id,
      queue_list: ^clt$data_value,
      queues: mmt$global_page_queue_list,
      ring_attributes: amt$ring_attributes,
      site_active_queue_count: 0 .. mmc$pq_shared_num_sites;

?? 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;
?? OLDTITLE ??
?? NEWTITLE := 'put_subtitle', EJECT ??

{  PURPOSE:
{    The procedure clp$new_page_procedure which is copied via *copyc from a common deck expects to call a
{    local procedure to put out subtitles. Since we do not need subtitles this proc is a dummy.

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

    PROCEND put_subtitle;
?? OLDTITLE ??
?? EJECT ??
    status.normal := TRUE;
    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    mmp$fetch_manage_memory_data_r3 (queues, ma_values, gpql_default, ma_default);
    mmp$fetch_site_active_q_cnt_r3 (site_active_queue_count);

    display_control := clv$nil_display_control;
    clv$titles_built := FALSE;
    clv$command_name := 'display_shared_queue_cycles';
    ring_attributes.r1 := #RING (^ring_attributes);
    ring_attributes.r2 := #RING (^ring_attributes);
    ring_attributes.r3 := #RING (^ring_attributes);
    clp$open_display_reference (pvt [p$output].value^.file_value^, ^clp$new_page_procedure, fsc$list,
          ring_attributes, display_control, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;
    osp$establish_block_exit_hndlr (^abort_handler);

    IF (display_control.page_format = amc$burstable_form) OR
          (display_control.page_format = amc$non_burstable_form) THEN
      clp$new_display_page (display_control, ignore_status);
      clp$new_display_line (display_control, 2, ignore_status);
    IFEND;

    IF pvt [p$queue].value^.kind = clc$keyword THEN { ALL is the only keyword allowed. }
      first_queue_id := mmc$pq_shared_first;
      last_queue_id := mmc$pq_shared_last_site;
    ELSE
      first_queue_id := mmc$pq_shared_first_site;
      last_queue_id := mmc$pq_shared_last_sys;
      queue_list := pvt [p$queue].value;
      WHILE queue_list <> NIL DO
        IF queue_list^.element_value^.keyword_value = 'SYSTEM' THEN
          first_queue_id := mmc$pq_shared_first;
        ELSEIF queue_list^.element_value^.keyword_value = 'ACTIVE_SITE_DEFINED' THEN
          last_queue_id := mmc$pq_shared_first_site + site_active_queue_count - 1;
        IFEND;
        queue_list := queue_list^.link;
      WHILEND;
    IFEND;

    IF (first_queue_id = mmc$pq_shared_first_site) AND (site_active_queue_count = 0) THEN
      line.data := ' No site defined shared queues are active.';
      clp$put_display (display_control, line.data, clc$no_trim, ignore_status);
    ELSE
      line.data := ' ';
      line.defined_age_cycles_name := 'Cycles   1         2         3';
      clp$put_display (display_control, line.data, clc$no_trim, ignore_status);
      line.data := ' ';
      line.queue_name := 'QUEUE';
      line.age_cycle_title := '12345678901234567890123456789012';
      clp$put_display (display_control, line.data, clc$no_trim, ignore_status);

      FOR queue_id := first_queue_id TO last_queue_id DO
        line.data := ' ';
        IF queue_id < mmc$pq_shared_first_site THEN
          line.queue_part.data := v$dissqa_data [queue_id];
        ELSE
          line.queue_part.data := v$dissqa_data [mmc$pq_shared_first_site];
          clp$convert_integer_to_rjstring ((queue_id - mmc$pq_shared_last_sys), 10, FALSE, '0',
                line.queue_part.site_number, ignore_status);
        IFEND;

        FOR age_cycle := mmc$page_queue_age_cycle_min TO mmc$page_queue_age_cycle_max DO
          IF age_cycle IN queues [queue_id].age_cycles THEN
            line.age_cycles (age_cycle + 1) := 'X';
          IFEND;
        FOREND;

        clp$put_display (display_control, line.data, clc$trim, ignore_status);
      FOREND;
    IFEND;

    clp$close_display (display_control, ignore_status);
    osp$disestablish_cond_handler;

  PROCEND display_shared_queue_cycles;
?? OLDTITLE ??
?? NEWTITLE := 'evaluate_selected_queues', EJECT ??

  PROCEDURE evaluate_selected_queues
    (    value_p: ^clt$data_value;
     VAR queues_selected: t$shared_queues;
     VAR memory_attributes_selected: boolean);

    VAR
      list_p: ^clt$data_value,
      option_p: ^clt$data_value,
      shared_site_queues: t$shared_queues;

    queues_selected := $t$shared_queues [];
    shared_site_queues := -v$shared_system_queues;
    memory_attributes_selected := FALSE;

    list_p := value_p;

  /determine_requested_queues/
    WHILE list_p <> NIL DO
      option_p := list_p^.element_value;
      list_p := list_p^.link;

      IF option_p^.keyword_value = 'ALL' THEN
        queues_selected := -$t$shared_queues [];
        memory_attributes_selected := TRUE;
        EXIT /determine_requested_queues/; {----->
      ELSEIF option_p^.keyword_value = 'DEVICE_FILE' THEN
        queues_selected := queues_selected + $t$shared_queues [mmc$pq_shared_device_file];
      ELSEIF option_p^.keyword_value = 'EXECUTABLE_FILE' THEN
        queues_selected := queues_selected + $t$shared_queues [mmc$pq_shared_pf_execute];
      ELSEIF option_p^.keyword_value = 'FILE_SERVER' THEN
        queues_selected := queues_selected + $t$shared_queues [mmc$pq_shared_file_server];
      ELSEIF option_p^.keyword_value = 'MEMORY_ATTRIBUTE' THEN
        memory_attributes_selected := TRUE;
      ELSEIF option_p^.keyword_value = 'NON_EXECUTABLE_FILE' THEN
        queues_selected := queues_selected + $t$shared_queues [mmc$pq_shared_pf_non_execute];
      ELSEIF option_p^.keyword_value = 'OTHER' THEN
        queues_selected := queues_selected + $t$shared_queues [mmc$pq_shared_other];
      ELSEIF option_p^.keyword_value = 'SHARED_QUEUE_ATTRIBUTE' THEN
        queues_selected := -$t$shared_queues [];
      ELSEIF option_p^.keyword_value = 'SITE_DEFINED' THEN
        queues_selected := queues_selected + shared_site_queues;
      ELSEIF option_p^.keyword_value = 'SYSTEM' THEN
        queues_selected := queues_selected + v$shared_system_queues;
      ELSEIF option_p^.keyword_value = 'TASK_SERVICE' THEN
        queues_selected := queues_selected + $t$shared_queues [mmc$pq_shared_task_service];
      ELSEIF option_p^.keyword_value = 'SITE_01' THEN
        queues_selected := queues_selected + $t$shared_queues [mmc$pq_shared_site_01];
      ELSEIF option_p^.keyword_value = 'SITE_02' THEN
        queues_selected := queues_selected + $t$shared_queues [mmc$pq_shared_site_02];
      ELSEIF option_p^.keyword_value = 'SITE_03' THEN
        queues_selected := queues_selected + $t$shared_queues [mmc$pq_shared_site_03];
      ELSEIF option_p^.keyword_value = 'SITE_04' THEN
        queues_selected := queues_selected + $t$shared_queues [mmc$pq_shared_site_04];
      ELSEIF option_p^.keyword_value = 'SITE_05' THEN
        queues_selected := queues_selected + $t$shared_queues [mmc$pq_shared_site_05];
      ELSEIF option_p^.keyword_value = 'SITE_06' THEN
        queues_selected := queues_selected + $t$shared_queues [mmc$pq_shared_site_06];
      ELSEIF option_p^.keyword_value = 'SITE_07' THEN
        queues_selected := queues_selected + $t$shared_queues [mmc$pq_shared_site_07];
      ELSEIF option_p^.keyword_value = 'SITE_08' THEN
        queues_selected := queues_selected + $t$shared_queues [mmc$pq_shared_site_08];
      ELSEIF option_p^.keyword_value = 'SITE_09' THEN
        queues_selected := queues_selected + $t$shared_queues [mmc$pq_shared_site_09];
      ELSEIF option_p^.keyword_value = 'SITE_10' THEN
        queues_selected := queues_selected + $t$shared_queues [mmc$pq_shared_site_10];
      ELSEIF option_p^.keyword_value = 'SITE_11' THEN
        queues_selected := queues_selected + $t$shared_queues [mmc$pq_shared_site_11];
      ELSEIF option_p^.keyword_value = 'SITE_12' THEN
        queues_selected := queues_selected + $t$shared_queues [mmc$pq_shared_site_12];
      ELSEIF option_p^.keyword_value = 'SITE_13' THEN
        queues_selected := queues_selected + $t$shared_queues [mmc$pq_shared_site_13];
      ELSEIF option_p^.keyword_value = 'SITE_14' THEN
        queues_selected := queues_selected + $t$shared_queues [mmc$pq_shared_site_14];
      ELSEIF option_p^.keyword_value = 'SITE_15' THEN
        queues_selected := queues_selected + $t$shared_queues [mmc$pq_shared_site_15];
      ELSEIF option_p^.keyword_value = 'SITE_16' THEN
        queues_selected := queues_selected + $t$shared_queues [mmc$pq_shared_site_16];
      ELSEIF option_p^.keyword_value = 'SITE_17' THEN
        queues_selected := queues_selected + $t$shared_queues [mmc$pq_shared_site_17];
      ELSEIF option_p^.keyword_value = 'SITE_18' THEN
        queues_selected := queues_selected + $t$shared_queues [mmc$pq_shared_site_18];
      ELSEIF option_p^.keyword_value = 'SITE_19' THEN
        queues_selected := queues_selected + $t$shared_queues [mmc$pq_shared_site_19];
      ELSEIF option_p^.keyword_value = 'SITE_20' THEN
        queues_selected := queues_selected + $t$shared_queues [mmc$pq_shared_site_20];
      ELSEIF option_p^.keyword_value = 'SITE_21' THEN
        queues_selected := queues_selected + $t$shared_queues [mmc$pq_shared_site_21];
      ELSEIF option_p^.keyword_value = 'SITE_22' THEN
        queues_selected := queues_selected + $t$shared_queues [mmc$pq_shared_site_22];
      ELSEIF option_p^.keyword_value = 'SITE_23' THEN
        queues_selected := queues_selected + $t$shared_queues [mmc$pq_shared_site_23];
      ELSEIF option_p^.keyword_value = 'SITE_24' THEN
        queues_selected := queues_selected + $t$shared_queues [mmc$pq_shared_site_24];
      ELSEIF option_p^.keyword_value = 'SITE_25' THEN
        queues_selected := queues_selected + $t$shared_queues [mmc$pq_shared_site_25];
      IFEND;
    WHILEND /determine_requested_queues/;

  PROCEND evaluate_selected_queues;
?? OLDTITLE ??
?? NEWTITLE := 'quit', EJECT ??

{ PURPOSE:
{   This procedure processes the QUIT Command which is the command to terminate the Manage Memory Utility.
{   It terminates the utility by ending the include file.  This will cause control to return to the
{   initiation procedure which is mmp$manage_memory where the utility is ended.

  PROCEDURE quit
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE quit, qui (
{   status)

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??
  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 1] of clt$pdt_parameter_name,
      parameters: array [1 .. 1] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [92, 1, 14, 9, 47, 55, 114],
    clc$command, 1, 1, 0, 0, 0, 0, 1, ''], [
    ['STATUS                         ',clc$nominal_entry, 1]],
    [
{ PARAMETER 1
    [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$status_type]]];
?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$status = 1;

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

    status.normal := TRUE;
    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    clp$end_include (c$utility_name, status);

  PROCEND quit;

?? OLDTITLE ??
?? NEWTITLE := 'reset_dynamic_aging', EJECT ??

  PROCEDURE reset_dynamic_aging
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

*copyc mmd$mmu_reset_dynamic_aging

    VAR
      ignore_memory_attrib_selected: boolean,
      queues_selected: t$shared_queues,
      reset_values: mmt$mmu_reset_values;

?? NEWTITLE := 'eveluate_reset_value', EJECT ??

    PROCEDURE eveluate_reset_value
      (    value_p: ^clt$data_value;
       VAR reset_value: mmt$mmu_reset_value);

      IF value_p = NIL THEN
        reset_value.kind := mmc$mmu_current_value;
      ELSEIF value_p^.kind = clc$integer THEN
        reset_value.kind := mmc$mmu_specified_value;
        reset_value.specified_value := value_p^.integer_value.value;
      ELSEIF value_p^.keyword_value = 'DEFAULT' THEN
        reset_value.kind := mmc$mmu_default_value;
      ELSEIF value_p^.keyword_value = 'NOMINAL' THEN
        reset_value.kind := mmc$mmu_nominal_value;
      ELSE { value_p^.keyword_value = 'CURRENT'
        reset_value.kind := mmc$mmu_current_value;
      IFEND;

    PROCEND eveluate_reset_value;
?? OLDTITLE ??
?? EJECT ??

    status.normal := TRUE;
    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    evaluate_selected_queues (pvt [p$queue].value, queues_selected, ignore_memory_attrib_selected);

    eveluate_reset_value (pvt [p$age_interval_modified].value, reset_values [mmc$mmu_age_interval_modified]);
    eveluate_reset_value (pvt [p$age_interval_unmodified].
          value, reset_values [mmc$mmu_age_interval_unmodified]);
    eveluate_reset_value (pvt [p$minimum_size].value, reset_values [mmc$mmu_minimum]);
    eveluate_reset_value (pvt [p$maximum_size].value, reset_values [mmc$mmu_maximum]);

    mmp$reset_dynamic_aging_r3 (queues_selected, reset_values, status);

  PROCEND reset_dynamic_aging;
?? OLDTITLE ??
?? NEWTITLE := 'set_debug_options', EJECT ??

  PROCEDURE set_debug_options
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

*copyc mmd$mmu_set_debug_options

    VAR
      debug_options: mmt$mmu_debug_options,
      element_value_p: ^clt$data_value,
      value_p: ^clt$data_value;

    status.normal := TRUE;
    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    debug_options := mmv$debug_options;
    value_p := pvt [p$force_dynamic_aging_attribute].value;
    IF value_p^.kind = clc$keyword THEN
      IF value_p^.keyword_value = 'ALL' THEN
        debug_options.force_dynamic_aging_attributes := -$t$force_dynamic_aging_attribs [];
      ELSE
        debug_options.force_dynamic_aging_attributes := $t$force_dynamic_aging_attribs [];
      IFEND;
    ELSE {clc$list
      debug_options.force_dynamic_aging_attributes := $t$force_dynamic_aging_attribs [];
      WHILE value_p <> NIL DO
        element_value_p := value_p^.element_value;

        IF element_value_p <> NIL THEN
          IF element_value_p^.keyword_value = 'DISPLAY_MEMORY_ATTRIBUTES' THEN
            debug_options.force_dynamic_aging_attributes :=
                  debug_options.force_dynamic_aging_attributes +
                  $t$force_dynamic_aging_attribs [c$display_memory_attributes];
          ELSEIF element_value_p^.keyword_value = 'DISPLAY_SHARED_QUEUE_ATTRIBUTES' THEN
            debug_options.force_dynamic_aging_attributes :=
                  debug_options.force_dynamic_aging_attributes +
                  $t$force_dynamic_aging_attribs [c$display_shared_queue_attrib];
          ELSEIF element_value_p^.keyword_value = 'CHANGE_MEMORY_ATTRIBUTES' THEN
            debug_options.force_dynamic_aging_attributes :=
                  debug_options.force_dynamic_aging_attributes +
                  $t$force_dynamic_aging_attribs [c$change_memory_attributes];
          ELSEIF element_value_p^.keyword_value = 'CHANGE_SHARED_QUEUE_ATTRIBUTES' THEN
            debug_options.force_dynamic_aging_attributes :=
                  debug_options.force_dynamic_aging_attributes +
                  $t$force_dynamic_aging_attribs [c$change_shared_queue_attrib];
          IFEND;
        IFEND;

        value_p := value_p^.link;
      WHILEND;
    IFEND;

    mmp$mmu_set_debug_options (debug_options);

  PROCEND set_debug_options;
?? OLDTITLE ??
?? NEWTITLE := 'set_to_default', EJECT ??

{ PURPOSE:
{   This procedure processes the SET_TO_DEFAULT Command.  The command provides the capability to set the data
{   that can be changed by the Manage Memory Utility to their default values.  A Ring 3 helper routine is
{   called to fetch all of the data that can be changed.  The command is then cracked and the data is set to
{   defaults as directed by the command.  Then another helper routine is called to store all of the data back
{   into their normal locations.

  PROCEDURE set_to_default
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

*copyc mmd$mmu_set_to_default

    VAR
      gpql_default: mmt$mmu_gpql_default,
      ma_default: mmt$mmu_ma_default,
      ma_index: mmt$mmu_memory_attributes,
      ma_values: mmt$mmu_ma_values,
      memory_attributes_selected: boolean,
      queue_id: mmt$page_frame_queue_id,
      queues: mmt$global_page_queue_list,
      queues_selected: t$shared_queues;

    status.normal := TRUE;
    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    evaluate_selected_queues (pvt [p$set].value, queues_selected, memory_attributes_selected);

    mmp$fetch_manage_memory_data_r3 (queues, ma_values, gpql_default, ma_default);

    IF memory_attributes_selected THEN
      FOR ma_index := LOWERBOUND (v$mmu_info_ma) TO UPPERBOUND (v$mmu_info_ma) DO
        ma_values [v$mmu_info_ma [ma_index].index] := ma_default [v$mmu_info_ma [ma_index].index];
      FOREND;
    IFEND;

    FOR queue_id := mmc$pq_shared_first TO mmc$pq_shared_last DO
      IF queue_id IN queues_selected THEN
        queues [queue_id].queue_age_interval := gpql_default [queue_id].queue_age_interval;
        queues [queue_id].encrease_min_enable_dynamic_age :=
              gpql_default [queue_id].encrease_min_enable_dynamic_age;
        queues [queue_id].age_interval_actual_modified := gpql_default [queue_id].
              age_interval_actual_modified;
        queues [queue_id].age_interval_actual_unmodified :=
              gpql_default [queue_id].age_interval_actual_unmodified;
        queues [queue_id].age_interval_nominal_modified := gpql_default [queue_id].
              age_interval_nominal_modified;
        queues [queue_id].age_interval_nominal_unmodified :=
              gpql_default [queue_id].age_interval_nominal_unmodified;
        queues [queue_id].age_interval_modified_max := gpql_default [queue_id].age_interval_modified_max;
        queues [queue_id].age_interval_modified_min := gpql_default [queue_id].age_interval_modified_min;
        queues [queue_id].age_interval_unmodified_max := gpql_default [queue_id].age_interval_unmodified_max;
        queues [queue_id].age_interval_unmodified_min := gpql_default [queue_id].age_interval_unmodified_min;
        queues [queue_id].age_interval_neg_inc_modified := gpql_default [queue_id].
              age_interval_neg_inc_modified;
        queues [queue_id].age_interval_neg_inc_unmodified :=
              gpql_default [queue_id].age_interval_neg_inc_unmodified;
        queues [queue_id].age_interval_pos_inc_modified := gpql_default [queue_id].
              age_interval_pos_inc_modified;
        queues [queue_id].age_interval_pos_inc_unmodified :=
              gpql_default [queue_id].age_interval_pos_inc_unmodified;

        queues [queue_id].minimum_actual := gpql_default [queue_id].minimum_actual;
        queues [queue_id].minimum_nominal := gpql_default [queue_id].minimum_nominal;
        queues [queue_id].minimum_min := gpql_default [queue_id].minimum_min;
        queues [queue_id].minimum_max := gpql_default [queue_id].minimum_max;
        queues [queue_id].minimum_neg_inc := gpql_default [queue_id].minimum_neg_inc;
        queues [queue_id].minimum_neg_inc_pc := gpql_default [queue_id].minimum_neg_inc_pc;
        queues [queue_id].minimum_pos_inc := gpql_default [queue_id].minimum_pos_inc;
        queues [queue_id].minimum_pos_inc_pc := gpql_default [queue_id].minimum_pos_inc_pc;

        queues [queue_id].maximum_actual := gpql_default [queue_id].maximum_actual;
        queues [queue_id].maximum_actual_cycle := gpql_default [queue_id].maximum_actual_cycle;
        queues [queue_id].maximum_nominal := gpql_default [queue_id].maximum_nominal;
        queues [queue_id].maximum_min := gpql_default [queue_id].maximum_min;
        queues [queue_id].maximum_max := gpql_default [queue_id].maximum_max;
        queues [queue_id].maximum_neg_inc := gpql_default [queue_id].maximum_neg_inc;
        queues [queue_id].maximum_neg_inc_pc := gpql_default [queue_id].maximum_neg_inc_pc;
        queues [queue_id].maximum_pos_inc := gpql_default [queue_id].maximum_pos_inc;
        queues [queue_id].maximum_pos_inc_pc := gpql_default [queue_id].maximum_pos_inc_pc;

        queues [queue_id].age_cycles := gpql_default [queue_id].age_cycles;
      IFEND;
    FOREND;

    mmp$store_manage_memory_data_r3 (TRUE {= Reset dynamic aging} , queues, ma_values, status);

  PROCEND set_to_default;
?? OLDTITLE ??
?? NEWTITLE := 'p$$memory_attribute', EJECT ??

  PROCEDURE p$$memory_attribute
    (    parameter_list: clt$parameter_list;
     VAR work_area {input, output} : ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

{ FUNCTION $memory_attribute

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

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
    recend := [
    [1,
    [95, 8, 25, 9, 53, 34, 697],
    clc$function, 0, 0, 0, 0, 0, 0, 0, '']];

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

    CONST
      c$memory_attributes_count = 16;

    VAR
      gpql_default: mmt$mmu_gpql_default,
      ma_default: mmt$mmu_ma_default,
      ma_index: mmt$mmu_memory_attributes,
      ma_values: mmt$mmu_ma_values,
      queues: mmt$global_page_queue_list,
      record_index: 0 .. clc$max_fields,
      result_p: ^clt$data_value;

?? NEWTITLE := 'p$abort_handler', EJECT ??

{ PURPOSE:
{   This abort handler processes segment_access, block exit and system
{   conditions.
{
{   A block exit (or segment access) condition can occur when a NIL pointer
{   is returned by NEXTing the work_area. This is then assumed to be a
{   work_area overflow.

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

      VAR
        local_status_p: ^ost$status;

      CASE condition.selector OF
      = mmc$segment_access_condition, pmc$block_exit_processing =
        osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
        osp$append_status_parameter (osc$status_parameter_delimiter, '$MEMORY_ATTRIBUTE', status);
        EXIT p$$memory_attribute; {----->

      = pmc$system_conditions =
        IF status.normal THEN
          PUSH local_status_p;
          osp$set_status_from_condition ('PM', condition, save_area, status, local_status_p^);
        IFEND;

        EXIT p$$memory_attribute; {----->

      ELSE
        pmp$continue_to_cause (pmc$execute_standard_procedure, handler_status);
      CASEND;

    PROCEND p$abort_handler;
?? OLDTITLE ??
?? EJECT ??
    status.normal := TRUE;
    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, NIL, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    mmp$fetch_manage_memory_data_r3 (queues, ma_values, gpql_default, ma_default);

    osp$establish_condition_handler (^p$abort_handler, TRUE {= block exit} );

    result := NIL;
    record_index := 0;
    result_p := clf#make_record_header_value ($INTEGER (UPPERVALUE (mmt$mmu_memory_attributes)) -
          $INTEGER (LOWERVALUE (mmt$mmu_memory_attributes)) + 1, work_area);

    FOR ma_index := LOWERBOUND (v$mmu_info_ma) TO UPPERBOUND (v$mmu_info_ma) DO
      clp#add_record_field (v$mmu_info_ma [ma_index].name,
            clf#make_clt$integer_value (ma_values [v$mmu_info_ma [ma_index].index], 10, FALSE, work_area),
            record_index, result_p);
    FOREND;

    osp$disestablish_cond_handler;

    result := result_p;

  PROCEND p$$memory_attribute;
?? OLDTITLE ??
?? NEWTITLE := 'p$$shared_queue_attribute', EJECT ??

  PROCEDURE p$$shared_queue_attribute
    (    parameter_list: clt$parameter_list;
     VAR work_area {input, output} : ^clt$work_area;
     VAR result: ^clt$data_value;
     VAR status: ost$status);

{ FUNCTION $shared_queue_attribute (
{   queue: any of
{       key
{         all
{       keyend
{       list of key
{         (active_site_defined, asd)
{         (system, s)
{       keyend
{     anyend = (active_site_defined, system)
{   )

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

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 1] of clt$pdt_parameter_name,
      parameters: array [1 .. 1] 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_v2,
          element_type_spec: record
            header: clt$type_specification_header,
            qualifier: clt$keyword_type_qualifier,
            keyword_specs: array [1 .. 4] of clt$keyword_specification,
          recend,
        recend,
        default_value: string (29),
      recend,
    recend := [
    [1,
    [95, 8, 25, 9, 51, 19, 775],
    clc$function, 1, 1, 0, 0, 0, 0, 0, ''], [
    ['QUEUE                          ',clc$nominal_entry, 1]],
    [
{ 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, 235, clc$optional_default_parameter, 0, 29
  ]],
{ 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]]
      ],
    171, [[1, 0, clc$list_type], [155, 1, clc$max_list_size, 0, FALSE, FALSE],
        [[1, 0, clc$keyword_type], [4], [
        ['ACTIVE_SITE_DEFINED            ', clc$nominal_entry,
  clc$normal_usage_entry, 1],
        ['ASD                            ', clc$abbreviation_entry,
  clc$normal_usage_entry, 1],
        ['S                              ', clc$abbreviation_entry,
  clc$normal_usage_entry, 2],
        ['SYSTEM                         ', clc$nominal_entry,
  clc$normal_usage_entry, 2]]
        ]
      ]
    ,
    '(active_site_defined, system)']];

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

    CONST
      p$queue = 1;

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

    VAR
      first_queue_id: mmt$page_frame_queue_id,
      gpql_default: mmt$mmu_gpql_default,
      last_queue_id: mmt$page_frame_queue_id,
      ma_default: mmt$mmu_ma_default,
      ma_values: mmt$mmu_ma_values,
      queue_id: mmt$page_frame_queue_id,
      queue_list: ^clt$data_value,
      queues: mmt$global_page_queue_list,
      site_active_queue_count: 0 .. mmc$pq_shared_num_sites,
      value_list_p: ^clt$data_value,
      value_list_pp: ^^clt$data_value;

?? NEWTITLE := '[UNSAFE] f$make_queue_attribute_value', EJECT ??

    FUNCTION [UNSAFE] f$make_queue_attribute_value
      (    queues: mmt$global_page_queue_list;
           queue_id: mmt$page_frame_queue_id;
       VAR work_area: {input, output} ^clt$work_area): ^clt$data_value;

      CONST
        c$queue_attributes_count = 35;

      TYPE
        t$queue_name = record
          case 0 .. 1 of
          = 0 =
            data: string (20),
          = 1 =
            site_name: string (5),
            site_number: string (2),
          casend,
        recend;

      VAR
        ignore_status: ost$status,
        queue_name: t$queue_name,
        record_index: 0 .. clc$max_fields,
        result_p: ^clt$data_value;

      IF queue_id < mmc$pq_shared_first_site THEN
        queue_name.data := v$dissqa_data [queue_id];
      ELSE
        queue_name.data := v$dissqa_data [mmc$pq_shared_first_site];
        clp$convert_integer_to_rjstring ((queue_id - mmc$pq_shared_last_sys), 10, FALSE, '0',
              queue_name.site_number, ignore_status);
      IFEND;

      record_index := 0;
      result_p := clf#make_record_header_value (c$queue_attributes_count, work_area);

      clp#add_record_field ('QUEUE', clf#make_keyword_value (queue_name.data, work_area), record_index,
            result_p);

      clp#add_record_field ('SIZE', clf#make_clt$integer_value
            (queues [queue_id].pqle.count, 10, FALSE, work_area), record_index, result_p);

      clp#add_record_field ('QUEUE_CYCLIC_AGE', clf#make_clt$integer_value
            (queues [queue_id].queue_cyclic_age, 10, FALSE, work_area), record_index, result_p);

      clp#add_record_field ('QUEUE_AGE_INTERVAL', clf#make_clt$integer_value
            (queues [queue_id].queue_age_interval, 10, FALSE, work_area), record_index, result_p);

      clp#add_record_field ('ENCREASE_MIN_ENABLE_DYNAMIC_AGE',
            clf#make_clt$integer_value (queues [queue_id].encrease_min_enable_dynamic_age, 10, FALSE,
            work_area), record_index, result_p);

      clp#add_record_field ('AGE_INTERVAL_ACTUAL_MODIFIED',
            clf#make_clt$integer_value (queues [queue_id].age_interval_actual_modified, 10, FALSE, work_area),
            record_index, result_p);

      clp#add_record_field ('AGE_INTERVAL_ACTUAL_UNMODIFIED',
            clf#make_clt$integer_value (queues [queue_id].age_interval_actual_unmodified, 10, FALSE,
            work_area), record_index, result_p);

      clp#add_record_field ('AGE_INTERVAL_NOMINAL_MODIFIED',
            clf#make_clt$integer_value (queues [queue_id].age_interval_nominal_modified, 10, FALSE,
            work_area), record_index, result_p);

      clp#add_record_field ('AGE_INTERVAL_NOMINAL_UNMODIFIED',
            clf#make_clt$integer_value (queues [queue_id].age_interval_nominal_unmodified, 10, FALSE,
            work_area), record_index, result_p);

      clp#add_record_field ('AGE_INTERVAL_MODIFIED_MAX', clf#make_clt$integer_value
            (queues [queue_id].age_interval_modified_max, 10, FALSE, work_area), record_index, result_p);

      clp#add_record_field ('AGE_INTERVAL_MODIFIED_MIN', clf#make_clt$integer_value
            (queues [queue_id].age_interval_modified_min, 10, FALSE, work_area), record_index, result_p);

      clp#add_record_field ('AGE_INTERVAL_UNMODIFIED_MAX',
            clf#make_clt$integer_value (queues [queue_id].age_interval_unmodified_max, 10, FALSE, work_area),
            record_index, result_p);

      clp#add_record_field ('AGE_INTERVAL_UNMODIFIED_MIN',
            clf#make_clt$integer_value (queues [queue_id].age_interval_unmodified_min, 10, FALSE, work_area),
            record_index, result_p);

      clp#add_record_field ('AGE_INTERVAL_NEG_INC_MODIFIED',
            clf#make_clt$integer_value (queues [queue_id].age_interval_neg_inc_modified, 10, FALSE,
            work_area), record_index, result_p);

      clp#add_record_field ('AGE_INTERVAL_NEG_INC_UNMODIFIED',
            clf#make_clt$integer_value (queues [queue_id].age_interval_neg_inc_unmodified, 10, FALSE,
            work_area), record_index, result_p);

      clp#add_record_field ('AGE_INTERVAL_POS_INC_MODIFIED',
            clf#make_clt$integer_value (queues [queue_id].age_interval_pos_inc_modified, 10, FALSE,
            work_area), record_index, result_p);

      clp#add_record_field ('AGE_INTERVAL_POS_INC_UNMODIFIED',
            clf#make_clt$integer_value (queues [queue_id].age_interval_pos_inc_unmodified, 10, FALSE,
            work_area), record_index, result_p);

      clp#add_record_field ('MINIMUM_ACTUAL', clf#make_clt$integer_value
            (queues [queue_id].minimum_actual, 10, FALSE, work_area), record_index, result_p);

      clp#add_record_field ('MINIMUM_NOMINAL', clf#make_clt$integer_value
            (queues [queue_id].minimum_nominal, 10, FALSE, work_area), record_index, result_p);

      clp#add_record_field ('MINIMUM_MIN', clf#make_clt$integer_value
            (queues [queue_id].minimum_min, 10, FALSE, work_area), record_index, result_p);

      clp#add_record_field ('MINIMUM_MAX', clf#make_clt$integer_value
            (queues [queue_id].minimum_max, 10, FALSE, work_area), record_index, result_p);

      clp#add_record_field ('MINIMUM_NEG_INC', clf#make_clt$integer_value
            (queues [queue_id].minimum_neg_inc, 10, FALSE, work_area), record_index, result_p);

      clp#add_record_field ('MINIMUM_NEG_INC_PC', clf#make_clt$integer_value
            (queues [queue_id].minimum_neg_inc_pc, 10, FALSE, work_area), record_index, result_p);

      clp#add_record_field ('MINIMUM_POS_INC', clf#make_clt$integer_value
            (queues [queue_id].minimum_pos_inc, 10, FALSE, work_area), record_index, result_p);

      clp#add_record_field ('MINIMUM_POS_INC_PC', clf#make_clt$integer_value
            (queues [queue_id].minimum_pos_inc_pc, 10, FALSE, work_area), record_index, result_p);

      clp#add_record_field ('MAXIMUM_ACTUAL', clf#make_clt$integer_value
            (queues [queue_id].maximum_actual, 10, FALSE, work_area), record_index, result_p);

      clp#add_record_field ('MAXIMUM_ACTUAL_CYCLE', clf#make_clt$integer_value
            (queues [queue_id].maximum_actual_cycle, 10, FALSE, work_area), record_index, result_p);

      clp#add_record_field ('MAXIMUM_NOMINAL', clf#make_clt$integer_value
            (queues [queue_id].maximum_nominal, 10, FALSE, work_area), record_index, result_p);

      clp#add_record_field ('MAXIMUM_MIN', clf#make_clt$integer_value
            (queues [queue_id].maximum_min, 10, FALSE, work_area), record_index, result_p);

      clp#add_record_field ('MAXIMUM_MAX', clf#make_clt$integer_value
            (queues [queue_id].maximum_max, 10, FALSE, work_area), record_index, result_p);

      clp#add_record_field ('MAXIMUM_NEG_INC', clf#make_clt$integer_value
            (queues [queue_id].maximum_neg_inc, 10, FALSE, work_area), record_index, result_p);

      clp#add_record_field ('MAXIMUM_NEG_INC_PC', clf#make_clt$integer_value
            (queues [queue_id].maximum_neg_inc_pc, 10, FALSE, work_area), record_index, result_p);

      clp#add_record_field ('MAXIMUM_POS_INC', clf#make_clt$integer_value
            (queues [queue_id].maximum_pos_inc, 10, FALSE, work_area), record_index, result_p);

      clp#add_record_field ('MAXIMUM_POS_INC_PC', clf#make_clt$integer_value
            (queues [queue_id].maximum_pos_inc_pc, 10, FALSE, work_area), record_index, result_p);

      IF queues [queue_id].age_cycles = -$mmt$page_queue_age_cycles [] THEN
        clp#add_record_field ('AGE_CYCLES', clf#make_keyword_value ('ALL', work_area),
              record_index, result_p);
      ELSE
        clp#add_record_field ('AGE_CYCLES', f$make_queue_cycles_value
              (queues [queue_id].age_cycles, work_area), record_index, result_p);
      IFEND;

      f$make_queue_attribute_value := result_p;

    FUNCEND f$make_queue_attribute_value;
?? OLDTITLE ??
?? NEWTITLE := '[UNSAFE] f$make_queue_cycles_value', EJECT ??

    FUNCTION [UNSAFE] f$make_queue_cycles_value
      (    queue_cycles: mmt$page_queue_age_cycles;
       VAR work_area: {input, output} ^clt$work_area): ^clt$data_value;

      VAR
        queue_cycle: mmt$page_queue_age_cycle,
        value_list_p: ^clt$data_value,
        value_list_pp: ^^clt$data_value;

      value_list_pp := ^value_list_p;

      FOR queue_cycle := mmc$page_queue_age_cycle_min TO mmc$page_queue_age_cycle_max DO
        IF queue_cycle IN queue_cycles THEN
          value_list_pp^ := clf#make_list_value (clf#make_clt$integer_value
                (queue_cycle + 1, 10, FALSE, work_area), work_area);

          value_list_pp := ^value_list_pp^^.link;
        IFEND;
      FOREND;

      IF value_list_pp = ^value_list_p THEN
        f$make_queue_cycles_value := clf#make_list_value (NIL, work_area);
      ELSE
        f$make_queue_cycles_value := value_list_p;
      IFEND;

    FUNCEND f$make_queue_cycles_value;
?? OLDTITLE ??
?? NEWTITLE := 'p$abort_handler', EJECT ??

{ PURPOSE:
{   This abort handler processes segment_access, block exit and system
{   conditions.
{
{   A block exit (or segment access) condition can occur when a NIL pointer
{   is returned by NEXTing the work_area. This is then assumed to be a
{   work_area overflow.

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

      VAR
        local_status_p: ^ost$status;

      CASE condition.selector OF
      = mmc$segment_access_condition, pmc$block_exit_processing =
        osp$set_status_abnormal ('CL', cle$work_area_overflow, '', status);
        osp$append_status_parameter (osc$status_parameter_delimiter, '$SHARED_QUEUE_ATTRIBUTE', status);
        EXIT p$$shared_queue_attribute; {----->

      = pmc$system_conditions =
        IF status.normal THEN
          PUSH local_status_p;
          osp$set_status_from_condition ('PM', condition, save_area, status, local_status_p^);
        IFEND;

        EXIT p$$shared_queue_attribute; {----->

      ELSE
        pmp$continue_to_cause (pmc$execute_standard_procedure, handler_status);
      CASEND;

    PROCEND p$abort_handler;
?? OLDTITLE ??
?? EJECT ??
    status.normal := TRUE;
    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;


    mmp$fetch_manage_memory_data_r3 (queues, ma_values, gpql_default, ma_default);
    mmp$fetch_site_active_q_cnt_r3 (site_active_queue_count);

    IF pvt [p$queue].value^.kind = clc$keyword THEN { ALL is the only keyword allowed. }
      first_queue_id := mmc$pq_shared_first;
      last_queue_id := mmc$pq_shared_last_site;
    ELSE
      first_queue_id := mmc$pq_shared_first_site;
      last_queue_id := mmc$pq_shared_last_sys;
      queue_list := pvt [p$queue].value;
      WHILE queue_list <> NIL DO
        IF queue_list^.element_value^.keyword_value = 'SYSTEM' THEN
          first_queue_id := mmc$pq_shared_first;
        ELSEIF queue_list^.element_value^.keyword_value = 'ACTIVE_SITE_DEFINED' THEN
          last_queue_id := mmc$pq_shared_first_site + site_active_queue_count - 1;
        IFEND;
        queue_list := queue_list^.link;
      WHILEND;
    IFEND;

    value_list_pp := ^value_list_p;

    FOR queue_id := first_queue_id TO last_queue_id DO
      value_list_pp^ := clf#make_list_value (f$make_queue_attribute_value (queues, queue_id, work_area),
            work_area);

      value_list_pp := ^value_list_pp^^.link;
    FOREND;

    osp$disestablish_cond_handler;

    IF value_list_pp = ^value_list_p THEN
      result := clf#make_list_value (NIL, work_area);
    ELSE
      result := value_list_p;
    IFEND;

  PROCEND p$$shared_queue_attribute;
?? OLDTITLE ??
?? NEWTITLE := 'mmp$manage_memory', EJECT ??

{ PURPOSE:
{   This is the initial procedure which is called via system command MANAGE_MEMORY.  It initiates the Manage
{   Memory Command Utility and thus activates the commands of the utility.  When the QUIT command is
{   executed, the utility is terminated.
{
{ DESIGN:
{   Initiates the utility.  Defines the utility commands via a command table.  All of the commands
{   defined are processed by different procedures which are all within this same module (MMM$MANAGE_MEMORY).
{
{ NOTES:
{   Any user may activate the utility.  When the commands are then executed, the ring3 helper routines
{   will enforce appropriate security.

  PROCEDURE [XDCL] mmp$manage_memory
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE manage_memory, manm (
{   status)

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??
  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 1] of clt$pdt_parameter_name,
      parameters: array [1 .. 1] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [92, 1, 14, 9, 31, 0, 173],
    clc$command, 1, 1, 0, 0, 0, 0, 1, ''], [
    ['STATUS                         ',clc$nominal_entry, 1]],
    [
{ PARAMETER 1
    [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$status_type]]];
?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$status = 1;

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

{ table n=v$command_table t=command sn=oss$job_paged_literal s=local
{ command n=(change_memory_attribute, change_memory_attributes, chama) p=change_memory_attribute cm=local
{ command n=(change_shared_queue_attribute, change_shared_queue_attributes, chasqa)   ..
{   p=change_shared_queue_attribute cm=local
{ command n=(display_memory_attribute, display_memory_attributes, disma) p=display_memory_attribute cm=local
{ command n=(display_shared_queue_attribute, display_shared_queue_attributes, display_shared_q_attribute, ..
{         dissqa) p=display_shared_queue_attribute cm=local
{ command n=(display_shared_queue_cycle, display_shared_queue_cycles, display_shared_q_cycle, dissqc)   ..
{   p=display_shared_queue_cycles cm=local
{ command n=(reset_dynamic_aging, resda) cm=local p=reset_dynamic_aging
{ command n=(quit, qui) p=quit cm=local
{ command n=(set_debug_options, setdo) p=set_debug_options cm=local a=h
{ command n=(set_to_default, settd) p=set_to_default cm=local
{ tablend

?? PUSH (LISTEXT := ON) ??

VAR
  v$command_table: [STATIC, READ, oss$job_paged_literal] ^clt$command_table := ^v$command_table_entries,

  v$command_table_entries: [STATIC, READ, oss$job_paged_literal] array [1 .. 25] of
      clt$command_table_entry := [
  {} ['CHAMA                          ', clc$abbreviation_entry, clc$normal_usage_entry, 1,
        clc$automatically_log, clc$linked_call, ^change_memory_attribute],
  {} ['CHANGE_MEMORY_ATTRIBUTE        ', clc$nominal_entry, clc$normal_usage_entry, 1,
        clc$automatically_log, clc$linked_call, ^change_memory_attribute],
  {} ['CHANGE_MEMORY_ATTRIBUTES       ', clc$alias_entry, clc$normal_usage_entry, 1,
        clc$automatically_log, clc$linked_call, ^change_memory_attribute],
  {} ['CHANGE_SHARED_QUEUE_ATTRIBUTE  ', clc$nominal_entry, clc$normal_usage_entry, 2,
        clc$automatically_log, clc$linked_call, ^change_shared_queue_attribute],
  {} ['CHANGE_SHARED_QUEUE_ATTRIBUTES ', clc$alias_entry, clc$normal_usage_entry, 2,
        clc$automatically_log, clc$linked_call, ^change_shared_queue_attribute],
  {} ['CHASQA                         ', clc$abbreviation_entry, clc$normal_usage_entry, 2,
        clc$automatically_log, clc$linked_call, ^change_shared_queue_attribute],
  {} ['DISMA                          ', clc$abbreviation_entry, clc$normal_usage_entry, 3,
        clc$automatically_log, clc$linked_call, ^display_memory_attribute],
  {} ['DISPLAY_MEMORY_ATTRIBUTE       ', clc$nominal_entry, clc$normal_usage_entry, 3,
        clc$automatically_log, clc$linked_call, ^display_memory_attribute],
  {} ['DISPLAY_MEMORY_ATTRIBUTES      ', clc$alias_entry, clc$normal_usage_entry, 3,
        clc$automatically_log, clc$linked_call, ^display_memory_attribute],
  {} ['DISPLAY_SHARED_QUEUE_ATTRIBUTE ', clc$nominal_entry, clc$normal_usage_entry, 4,
        clc$automatically_log, clc$linked_call, ^display_shared_queue_attribute],
  {} ['DISPLAY_SHARED_QUEUE_ATTRIBUTES', clc$alias_entry, clc$normal_usage_entry, 4,
        clc$automatically_log, clc$linked_call, ^display_shared_queue_attribute],
  {} ['DISPLAY_SHARED_QUEUE_CYCLE     ', clc$nominal_entry, clc$normal_usage_entry, 5,
        clc$automatically_log, clc$linked_call, ^display_shared_queue_cycles],
  {} ['DISPLAY_SHARED_QUEUE_CYCLES    ', clc$alias_entry, clc$normal_usage_entry, 5,
        clc$automatically_log, clc$linked_call, ^display_shared_queue_cycles],
  {} ['DISPLAY_SHARED_Q_ATTRIBUTE     ', clc$alias_entry, clc$normal_usage_entry, 4,
        clc$automatically_log, clc$linked_call, ^display_shared_queue_attribute],
  {} ['DISPLAY_SHARED_Q_CYCLE         ', clc$alias_entry, clc$normal_usage_entry, 5,
        clc$automatically_log, clc$linked_call, ^display_shared_queue_cycles],
  {} ['DISSQA                         ', clc$abbreviation_entry, clc$normal_usage_entry, 4,
        clc$automatically_log, clc$linked_call, ^display_shared_queue_attribute],
  {} ['DISSQC                         ', clc$abbreviation_entry, clc$normal_usage_entry, 5,
        clc$automatically_log, clc$linked_call, ^display_shared_queue_cycles],
  {} ['QUI                            ', clc$abbreviation_entry, clc$normal_usage_entry, 7,
        clc$automatically_log, clc$linked_call, ^quit],
  {} ['QUIT                           ', clc$nominal_entry, clc$normal_usage_entry, 7,
        clc$automatically_log, clc$linked_call, ^quit],
  {} ['RESDA                          ', clc$abbreviation_entry, clc$normal_usage_entry, 6,
        clc$automatically_log, clc$linked_call, ^reset_dynamic_aging],
  {} ['RESET_DYNAMIC_AGING            ', clc$nominal_entry, clc$normal_usage_entry, 6,
        clc$automatically_log, clc$linked_call, ^reset_dynamic_aging],
  {} ['SETDO                          ', clc$abbreviation_entry, clc$hidden_entry, 8,
        clc$automatically_log, clc$linked_call, ^set_debug_options],
  {} ['SETTD                          ', clc$abbreviation_entry, clc$normal_usage_entry, 9,
        clc$automatically_log, clc$linked_call, ^set_to_default],
  {} ['SET_DEBUG_OPTIONS              ', clc$nominal_entry, clc$hidden_entry, 8,
        clc$automatically_log, clc$linked_call, ^set_debug_options],
  {} ['SET_TO_DEFAULT                 ', clc$nominal_entry, clc$normal_usage_entry, 9,
        clc$automatically_log, clc$linked_call, ^set_to_default]];

?? POP ??

{ table n=v$function_table t=function sn=oss$job_paged_literal s=local
{ function n=($memory_attribute, $memory_attributes, $ma)     p=p$$memory_attribute cm=local
{ function n=($shared_queue_attribute,   $shared_queue_attributes,   $shared_q_attribute,           $sqa)  ..
{      p=p$$shared_queue_attribute cm=local
{ tablend

?? PUSH (LISTEXT := ON) ??

    VAR
      v$function_table: [STATIC, READ, oss$job_paged_literal] ^clt$function_processor_table :=
            ^v$function_table_entries,

      v$function_table_entries: [STATIC, READ, oss$job_paged_literal] array [1 .. 7] of
            clt$function_proc_table_entry := [
            {} ['$MA                            ', clc$abbreviation_entry, clc$normal_usage_entry, 1,
            clc$linked_call, ^p$$memory_attribute],
            {} ['$MEMORY_ATTRIBUTE              ', clc$nominal_entry, clc$normal_usage_entry, 1,
            clc$linked_call, ^p$$memory_attribute],
            {} ['$MEMORY_ATTRIBUTES             ', clc$alias_entry, clc$normal_usage_entry, 1,
            clc$linked_call, ^p$$memory_attribute],
            {} ['$SHARED_QUEUE_ATTRIBUTE        ', clc$nominal_entry, clc$normal_usage_entry, 2,
            clc$linked_call, ^p$$shared_queue_attribute],
            {} ['$SHARED_QUEUE_ATTRIBUTES       ', clc$alias_entry, clc$normal_usage_entry, 2,
            clc$linked_call, ^p$$shared_queue_attribute],
            {} ['$SHARED_Q_ATTRIBUTE            ', clc$alias_entry, clc$normal_usage_entry, 2,
            clc$linked_call, ^p$$shared_queue_attribute],
            {} ['$SQA                           ', clc$abbreviation_entry, clc$normal_usage_entry, 2,
            clc$linked_call, ^p$$shared_queue_attribute]];

?? POP ??

?? NEWTITLE := 'exit_condition_handler', EJECT ??

    PROCEDURE exit_condition_handler
      (    exit_condition: pmt$condition;
           exit_condition_descriptor: ^pmt$condition_information;
           save_area: ^ost$stack_frame_save_area;
       VAR condition_status: ost$status);

      VAR
        exit_status: ost$status;

      condition_status.normal := TRUE;
      CASE exit_condition.selector OF
      = pmc$block_exit_processing =
        clp$end_utility (c$utility_name, exit_status);
        ofp$display_status_message (' ', exit_status);
      ELSE
      CASEND;

    PROCEND exit_condition_handler;
?? OLDTITLE, EJECT ??

    VAR
      input_file: amt$local_file_name,
      local_status: ost$status,
      utility_attributes: array [1 .. 5] of clt$utility_attribute;

    status.normal := TRUE;
    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN; {----->
    IFEND;

    osp$establish_block_exit_hndlr (^exit_condition_handler);

  /manage_memory/
    BEGIN
      utility_attributes [1].key := clc$utility_command_search_mode;
      utility_attributes [1].command_search_mode := clc$global_command_search;
      utility_attributes [2].key := clc$utility_command_table;
      utility_attributes [2].command_table := v$command_table;
      utility_attributes [3].key := clc$utility_function_proc_table;
      utility_attributes [3].function_processor_table := v$function_table;
      utility_attributes [4].key := clc$utility_termination_command;
      utility_attributes [4].termination_command := 'quit';
      utility_attributes [5].key := clc$utility_prompt;
      utility_attributes [5].prompt.value := 'MMU';
      utility_attributes [5].prompt.size := 3;

      clp$begin_utility (c$utility_name, utility_attributes, status);
      IF NOT status.normal THEN
        EXIT /manage_memory/; {----->
      IFEND;

      clp$include_file (clc$current_command_input, '', c$utility_name, status);
      IF NOT status.normal THEN
        EXIT /manage_memory/; {----->
      IFEND;

      clp$end_utility (c$utility_name, status);
      IF NOT status.normal THEN
        EXIT /manage_memory/; {----->
      IFEND;

    END /manage_memory/;

    osp$disestablish_cond_handler;

  PROCEND mmp$manage_memory;
?? OLDTITLE ??
MODEND mmm$manage_memory;

