?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE Deadstart : Process Monitor Commands' ??
MODULE dpm$process_monitor_command;

{ PURPOSE:
{   This module contains the procedures for the commands that are entered at the critical window.

?? NEWTITLE := 'Global Declarations Referenced by This Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc dpc$console_row_size
*copyc dpt$console_parameter_block
*copyc dst$signal_contents
*copyc mtc$job_fixed_segment
*copyc osc$purge_map_and_cache
*copyc osd$virtual_address
*copyc ost$physical_channel_number
*copyc syc$monitor_segment_numbers
*copyc syt$debug_output_disposition
*copyc syt$dflt_debug_output_disposal
?? POP ??
*copyc dpp$display_error
*copyc dsp$mtr_get_ssr_data_seq_ptr
*copyc i#mtr_disable_traps
*copyc i#mtr_enable_traps
*copyc i#sync
*copyc i#test_set_bit
*copyc iop$down_disk_channel
*copyc iop$down_disk_controller
*copyc iop$down_disk_unit
*copyc jmp$find_jsn
*copyc jmf$ijle_p
*copyc jmp$resurrect_dead_jobs
*copyc mmp$volume_available
*copyc tmp$monitor_flag_job_tasks
*copyc tmp$monitor_ready_system_task
*copyc tmp$send_signal
*copyc tmp$set_monitor_flag
?? EJECT ??
*copyc avv$security_options
*copyc cmv$logical_pp_table_p
*copyc dmv$active_volume_table
*copyc dpv$critical_display_id
*copyc dpv$secure_input_line
*copyc dsv$mainframe_type
*copyc jmv$ajl_p
*copyc jmv$ijl_p
*copyc jmv$service_classes
*copyc jmv$system_ajl_ordinal
*copyc jmv$system_ijl_ordinal
*copyc mmv$gpql
*copyc mmv$manage_memory_utility
*copyc mtv$monitor_segment_table
*copyc mtv$nst_p
*copyc mtv$scb
*copyc tmv$system_job_monitor_gtid
*copyc tmv$tables_initialized
?? OLDTITLE ??
?? NEWTITLE := 'Global Declarations Declared by This Module', EJECT ??
  TYPE
    t$base = (c$base_10, c$base_16),
    t$command = string (dpc$console_row_size),
    t$command_length = 0 .. dpc$console_row_size;
?? EJECT ??
  VAR
    syv$debug_output_disposition: [XDCL, #GATE] syt$debug_output_disposition := syc$dod_null,
    syv$dflt_debug_output_disposal: [XDCL, #GATE] syt$dflt_debug_output_disposal := [1, syc$dod_null],

    v$expecting_password: boolean := FALSE,
    v$lock_main_window: boolean := FALSE;
?? OLDTITLE ??
?? NEWTITLE := 'convert_channel_number', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to generate a complete channel descriptor given
{   the channel number and the pp number.

  PROCEDURE convert_channel_number
    (    pp: iot$pp_number;
         channel_number: ost$physical_channel_number;
     VAR physical_channel: cmt$physical_channel);

    physical_channel.number := channel_number;

    IF cmv$logical_pp_table_p^ [pp].pp_info.channel.channel_protocol = dsc$cpt_cio THEN
      physical_channel.concurrent := TRUE;
    ELSE
      physical_channel.concurrent := FALSE;
    IFEND;

    physical_channel.port := cmc$unspecified_port;

    IF physical_channel.concurrent AND
          ((cmv$logical_pp_table_p^ [pp].controller_info.controller_type = cmc$mscm3_ct) OR
          (cmv$logical_pp_table_p^ [pp].controller_info.controller_type = cmc$ms5831_x) OR
          (cmv$logical_pp_table_p^ [pp].controller_info.controller_type = cmc$msntdc_1) OR
          (cmv$logical_pp_table_p^ [pp].controller_info.controller_type = cmc$msntdc_2) OR
          (cmv$logical_pp_table_p^ [pp].controller_info.controller_type = cmc$mshydra_ct)) THEN
      IF cmv$logical_pp_table_p^ [pp].pp_info.pp_interface_table_p^.unit_descriptors
            [cmv$logical_pp_table_p^ [pp].pp_info.pp_interface_table_p^.first_logical_unit].
            physical_path.port = 1 THEN
        physical_channel.port := cmc$port_b;
      ELSE
        physical_channel.port := cmc$port_a;
      IFEND;
    IFEND;

  PROCEND convert_channel_number;
?? OLDTITLE ??
?? NEWTITLE := 'parse_number', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to parse the monitor command line for a number.

  PROCEDURE parse_number
    (    desired_base: t$base;
         data_line: t$command;
     VAR data_line_index {input, output} : t$command_length;
     VAR number: integer;
     VAR number_good: boolean);

    VAR
      base: 0 .. 16,
      character: char,
      character_index: t$command_length,
      delimiter: boolean;

    number_good := TRUE;
    number := 0;

    character_index := 0;
    delimiter := FALSE;
    IF desired_base = c$base_10 THEN
      base := 10;
    ELSE
      base := 16;
    IFEND;

    WHILE data_line_index <= STRLENGTH (data_line) DO
      character := data_line (data_line_index);
      CASE character OF
      = ' ' =
        IF character_index > 0 THEN
          RETURN;
        IFEND;

      = '0' .. '9' =
        character_index := character_index + 1;
        number := number * base + ORD (character) - ORD ('0');

      = 'A' .. 'F', 'a' .. 'f' =
        IF desired_base = c$base_10 THEN
          number_good := FALSE;
          RETURN;
        IFEND;
        IF character >= 'a' THEN
          character := CHR (ORD (character) - ORD ('a') + ORD ('A'));
        IFEND;
        character_index := character_index + 1;
        number := number * base + ORD (character) - ORD ('A') + 10;

      = 'G' .. 'Z', 'g' .. 'z', '#', '$', '_', '@' =
        number_good := FALSE;
        RETURN;

      ELSE
        IF delimiter OR (character_index > 0) THEN
          RETURN;
        IFEND;
        delimiter := TRUE;
      CASEND;

      IF data_line_index = dpc$console_row_size THEN
        RETURN;
      ELSE
        data_line_index := data_line_index + 1;
      IFEND;
    WHILEND;

  PROCEND parse_number;
?? OLDTITLE ??
?? NEWTITLE := 'parse_word', EJECT ??

{ PURPOSE:
{   The purpose of this procedure is to parse the monitor command line for a word parameter.

  PROCEDURE parse_word
    (    data_line: t$command;
     VAR data_line_index {input, output} : t$command_length;
     VAR word: t$command;
     VAR word_length: t$command_length;
     VAR word_good: boolean);

    VAR
      character: char,
      delimiter: boolean;

    word_good := TRUE;
    word := ' ';
    word_length := 0;

    delimiter := FALSE;

    WHILE data_line_index <= STRLENGTH (data_line) DO
      character := data_line (data_line_index);
      CASE character OF
      = ' ' =
        IF word_length > 0 THEN
          RETURN;
        IFEND;

      = '0' .. '9' =
        IF word_length = 0 THEN
          word_good := FALSE;
          RETURN;
        IFEND;
        word_length := word_length + 1;
        word (word_length) := character;

      = 'A' .. 'Z', 'a' .. 'z' =
        IF character >= 'a' THEN
          character := CHR (ORD (character) - ORD ('a') + ORD ('A'));
        IFEND;
        word_length := word_length + 1;
        word (word_length) := character;

      = '#', '$', '_', '@' =
        word_length := word_length + 1;
        word (word_length) := character;

      = '"' =
        IF word_length = 0 THEN
          word_length := word_length + 1;
          word (word_length) := character;
          RETURN;
        ELSEIF delimiter OR (word_length > 0) THEN
          RETURN;
        ELSE
          delimiter := TRUE;
        IFEND;

      ELSE
        IF delimiter OR (word_length > 0) THEN
          RETURN;
        IFEND;
        delimiter := TRUE;
      CASEND;

      IF data_line_index = dpc$console_row_size THEN
        RETURN;
      ELSE
        data_line_index := data_line_index + 1;
      IFEND;
    WHILEND;

  PROCEND parse_word;
?? OLDTITLE ??
?? NEWTITLE := 'process_change_mdd_op_mode', EJECT ??

{ PURPOSE:
{   This procedure processes the 'CHANGE_MDD_OPERATING_MODE' command.  The format of
{   the command is as follows:
{     CHANGE_MDD_OPERATING_MODE ON/OFF PORT_NUMBER
{       on/off - specifies whether MDD is to be activated or deactivated.
{       port_number - specifies port number when activating MDD.  Default value is zero.

  PROCEDURE process_change_mdd_op_mode
    (    data_line: t$command;
     VAR data_line_index {input, output} : t$command_length);

    VAR
      activate_mdd: boolean,
      index: 1 .. 10,
      number: integer,
      parse_good: boolean,
      previously_set: boolean,
      sci_console_block_p: ^dpt$console_parameter_block,
      scipt_seq_p: ^SEQ ( * ),
      word: t$command,
      word_length: t$command_length;

    { Ensure that the command is valid on this mainframe.

    IF dsv$mainframe_type = dsc$mt_2000_mainframe THEN
      dpp$display_error ('*ERROR* MDD initiation not allowed on this mainframe.');
      RETURN;
    IFEND;

    { Get the ON or OFF status of the MDD operating mode.

    parse_word (data_line, data_line_index, word, word_length, parse_good);
    IF NOT parse_good THEN
      dpp$display_error ('*ERROR* First parameter is invalid, must be ON or OFF.');
      RETURN;
    IFEND;

    IF (word <> 'ON') AND (word <> 'OFF') THEN
      dpp$display_error ('*ERROR* Invalid MDD operating mode, must be ON or OFF.');
      RETURN;
    IFEND;

    activate_mdd := (word = 'ON');

    { Get the port number if specified.

    parse_number (c$base_10, data_line, data_line_index, number, parse_good);
    IF NOT parse_good THEN
      dpp$display_error ('*ERROR* Second parameter is invalid, must be a one or a zero.');
      RETURN;
    IFEND;

    IF number > 1 THEN
      dpp$display_error ('*ERROR* Invalid port number.');
      RETURN;
    IFEND;

    { Set the pointer to the SCI parameter table which is pointed to by word D7RS+2 in the EICB or it is the
    { SSR.  A bit in D7RS tells NOS/VE where the parameter table is located.

    IF mtv$nst_p^.d7rs2.scipt_in_the_ssr THEN
      dsp$mtr_get_ssr_data_seq_ptr (dsc$ssr_sci_parameter_table, scipt_seq_p);
      sci_console_block_p := #ADDRESS (1, #SEGMENT (scipt_seq_p), #OFFSET (scipt_seq_p));
    ELSE
      sci_console_block_p := #ADDRESS (1, syc$msn_cyber_170_cache_bypass, mtv$nst_p^.d7rs2.sci_table * 8);
    IFEND;

    { Interlock the SCI parameter table and update the new MDD status if the interlock was obtained.
    { The interlock bit must be cleared last so that SCI does not respond before NVE is finished.

    FOR index := 1 TO 10 DO
      i#test_set_bit (^sci_console_block_p^, dpc$sci_table_interlock_bit, previously_set);
      IF NOT previously_set THEN
        IF activate_mdd THEN
          sci_console_block_p^.mdd_console.console_active := TRUE;
          sci_console_block_p^.mdd_console.port_number := number;
          sci_console_block_p^.mdd_console.initiator := dpc$mdd_initiated_by_nosve;
        ELSE
          sci_console_block_p^.mdd_console.console_active := FALSE;
          sci_console_block_p^.mdd_console.port_number := 0;
          sci_console_block_p^.mdd_console.initiator := 0;
        IFEND;
        sci_console_block_p^.mdd_definition_changed := TRUE;
        sci_console_block_p^.interlocked := FALSE;
        RETURN;
      IFEND;
    FOREND;
    dpp$display_error ('*ERROR* SCI parameter table interlock unavailable.');

  PROCEND process_change_mdd_op_mode;

?? TITLE := ' process_disable_allocation', EJECT ??
{ PURPOSE:
{   This procedure processes the 'DISABLE_ALLOCATION' command.  The format of the command is as follows:
{     DISABLE_ALLOCATION PARAMETER1
{       PARAMETER1 is the AVT index.
{
{ NOTE:
{   This command is intended for testing purposes only.
{

  PROCEDURE process_disable_allocation
    (    data_line: t$command;
     VAR data_line_index {input, output} : t$command_length);

    VAR
      avti: integer,
      number: integer,
      parse_good: boolean;

    parse_number (c$base_10, data_line, data_line_index, number, parse_good);
    IF NOT parse_good THEN
      dpp$display_error ('*ERROR* First parameter is invalid.');
      RETURN;
    IFEND;

    IF (number > 0) AND (number <= UPPERBOUND (dmv$active_volume_table.table_p^)) THEN
      avti := number;
    ELSE
      dpp$display_error ('*ERROR* AVT index out of range.');
      RETURN;
    IFEND;


    IF dmv$active_volume_table.table_p^ [avti].entry_available THEN
      dpp$display_error ('*ERROR* Specified volume not active.');
    ELSE
      dmv$active_volume_table.table_p^ [avti].mass_storage.previous_allocation_allowed :=
            dmv$active_volume_table.table_p^ [avti].mass_storage.allocation_allowed;
      dmv$active_volume_table.table_p^ [avti].mass_storage.allocation_allowed := FALSE;
    IFEND;

  PROCEND process_disable_allocation;

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

{ PURPOSE:
{   This procedure processes the 'DISABLE_MAIN_OPERATOR_WINDOW' command and the 'ENABLE_MAIN_OPERATOR_WINDOW'
{   command.  The format of the commands are as follows:
{     DISABLE_MAIN_OPERATOR_WINDOW
{       and
{     ENABLE_MAIN_OPERATOR_WINDOW
{   This procedure starts the command and the process_password procedure completes the command.  The command
{   is broken into two parts so that the password can be entered without being displayed on the window.

  PROCEDURE process_dismow_enamow
    (    lock_window: boolean);

    v$expecting_password := TRUE;
    v$lock_main_window := lock_window;
    dpp$display_error ('Enter the Operation Password:');
    dpv$secure_input_line.window_id := dpv$critical_display_id;
    dpv$secure_input_line.secure := TRUE;

  PROCEND process_dismow_enamow;

?? TITLE := ' process_down_channel', EJECT ??
{ PURPOSE:
{   This procedure processes the 'DOWN_CHANNEL' command.  The format of the command is as follows:
{     DOWN_CHANNEL PARAMETER1 PARAMETER2
{       PARAMETER1 is the logical PP number.
{       PARAMETER2 is the channel number.
{       PARAMETER3 is the port letter.
{
{ NOTE:
{   This command is intended for testing purposes only.
{

  PROCEDURE process_down_channel
    (    data_line: t$command;
     VAR data_line_index {input, output} : t$command_length);

    VAR
      channel: 0 .. 33(16),
      down_status: syt$monitor_status,
      number: integer,
      parse_good: boolean,
      physical_channel: cmt$physical_channel,
      port_str: t$command,
      port_str_length: t$command_length,
      pp: iot$pp_number;

    parse_number (c$base_10, data_line, data_line_index, number, parse_good);
    IF NOT parse_good THEN
      dpp$display_error ('*ERROR* First parameter is invalid.');
      RETURN;
    IFEND;

    IF (number > 0) AND (number <= UPPERVALUE (iot$pp_number)) THEN
      pp := number;
    ELSE
      dpp$display_error ('*ERROR* pp number out of range.');
      RETURN;
    IFEND;

    parse_number (c$base_10, data_line, data_line_index, number, parse_good);
    IF NOT parse_good THEN
      dpp$display_error ('*ERROR* Second parameter is invalid.');
      RETURN;
    IFEND;

    IF (number > 0) AND (number <= 33(8)) THEN
      channel := number;
    ELSE
      dpp$display_error ('*ERROR* Channel number out of range.');
      RETURN;
    IFEND;
    convert_channel_number (pp, channel, physical_channel);

    parse_word (data_line, data_line_index, port_str, port_str_length, parse_good);
    IF NOT parse_good THEN
      dpp$display_error ('*ERROR* Third parameter is invalid.');
      RETURN;
    IFEND;

    IF port_str_length = 1 THEN
      IF (port_str = 'a') OR (port_str = 'A') THEN
        physical_channel.port := cmc$port_a;
      ELSEIF (port_str = 'b') OR (port_str = 'B') THEN
        physical_channel.port := cmc$port_b;
      ELSE
        dpp$display_error ('*ERROR* Port letter invalid.');
        RETURN;
      IFEND;
    ELSEIF port_str_length > 1 THEN
      dpp$display_error ('*ERROR* Port letter larger than one character.');
      RETURN;
    IFEND;

    iop$down_disk_channel (pp, physical_channel, down_status);
    IF NOT down_status.normal THEN
      dpp$display_error ('*ERROR* Bad status from IOP$DOWN_DISK_CHANNEL.');
    IFEND;

  PROCEND process_down_channel;

?? TITLE := ' process_down_controller', EJECT ??
{ PURPOSE:
{   This procedure processes the 'DOWN_CONTROLLER' command.  The format of the command is as follows:
{     DOWN_CONTROLLER PARAMETER1 PARAMETER2 PARAMETER3
{       PARAMETER1 is the logical PP number.
{       PARAMETER2 is the channel number.
{       PARAMETER3 is the equipment number.
{
{ NOTE:
{   This command is intended for testing purposes only.
{

  PROCEDURE process_down_controller
    (    data_line: t$command;
     VAR data_line_index {input, output} : t$command_length);

    VAR
      channel: ost$physical_channel_number,
      equipment: cmt$physical_equipment_number,
      down_status: syt$monitor_status,
      logical_unit: iot$logical_unit,
      number: integer,
      parse_good: boolean,
      physical_channel: cmt$physical_channel,
      pp: iot$pp_number,
      unit: cmt$physical_unit_number;

    parse_number (c$base_10, data_line, data_line_index, number, parse_good);
    IF NOT parse_good THEN
      dpp$display_error ('*ERROR* First parameter is invalid.');
      RETURN;
    IFEND;

    IF (number > 0) AND (number <= UPPERVALUE (iot$pp_number)) THEN
      pp := number;
    ELSE
      dpp$display_error ('*ERROR* pp number out of range.');
      RETURN;
    IFEND;

    parse_number (c$base_10, data_line, data_line_index, number, parse_good);
    IF NOT parse_good THEN
      dpp$display_error ('*ERROR* Second parameter is invalid.');
      RETURN;
    IFEND;

    IF (number > 0) AND (number <= UPPERVALUE(ost$physical_channel_number)) THEN
      channel := number;
    ELSE
      dpp$display_error ('*ERROR* Channel number out of range.');
      RETURN;
    IFEND;
    convert_channel_number (pp, channel, physical_channel);

    parse_number (c$base_10, data_line, data_line_index, number, parse_good);
    IF NOT parse_good THEN
      dpp$display_error ('*ERROR* Third parameter is invalid.');
      RETURN;
    IFEND;

    IF (number >= 0) AND (number <= UPPERVALUE(cmt$physical_equipment_number)) THEN
      equipment := number;
    ELSE
      dpp$display_error ('*ERROR* Equipment number out of range.');
      RETURN;
    IFEND;

    iop$down_disk_controller (pp, physical_channel, equipment, down_status);
    IF NOT down_status.normal THEN
      dpp$display_error ('*ERROR* Bad status from IOP$DOWN_DISK_CONTROLLER.');
    IFEND;

  PROCEND process_down_controller;

?? TITLE := ' process_down_unit', EJECT ??
{ PURPOSE:
{   This procedure processes the 'DOWN_UNIT' command.  The format of the command is as follows:
{     DOWN_UNIT PARAMETER1 PARAMETER2
{       PARAMETER1 is the logical PP number.
{       PARAMETER2 is the channel number.
{       PARAMETER3 is the equipment number.
{       PARAMETER4 is the unit number.
{       PARAMETER5 is the logical_unit number.
{
{ NOTE:
{   This command is intended for testing purposes only.
{

  PROCEDURE process_down_unit
    (    data_line: t$command;
     VAR data_line_index {input, output} : t$command_length);

    VAR
      channel: ost$physical_channel_number,
      equipment: cmt$physical_equipment_number,
      down_status: syt$monitor_status,
      logical_unit: iot$logical_unit,
      number: integer,
      parse_good: boolean,
      physical_channel: cmt$physical_channel,
      pp: iot$pp_number,
      unit: cmt$physical_unit_number;

    parse_number (c$base_10, data_line, data_line_index, number, parse_good);
    IF NOT parse_good THEN
      dpp$display_error ('*ERROR* First parameter is invalid.');
      RETURN;
    IFEND;

    IF (number > 0) AND (number <= UPPERVALUE (iot$pp_number)) THEN
      pp := number;
    ELSE
      dpp$display_error ('*ERROR* pp number out of range.');
      RETURN;
    IFEND;

    parse_number (c$base_10, data_line, data_line_index, number, parse_good);
    IF NOT parse_good THEN
      dpp$display_error ('*ERROR* Second parameter is invalid.');
      RETURN;
    IFEND;

    IF (number > 0) AND (number <= UPPERVALUE(ost$physical_channel_number)) THEN
      channel := number;
    ELSE
      dpp$display_error ('*ERROR* Channel number out of range.');
      RETURN;
    IFEND;
    convert_channel_number (pp, channel, physical_channel);

    parse_number (c$base_10, data_line, data_line_index, number, parse_good);
    IF NOT parse_good THEN
      dpp$display_error ('*ERROR* Third parameter is invalid.');
      RETURN;
    IFEND;

    IF (number >= 0) AND (number <= UPPERVALUE(cmt$physical_equipment_number)) THEN
      equipment := number;
    ELSE
      dpp$display_error ('*ERROR* Equipment number out of range.');
      RETURN;
    IFEND;

    parse_number (c$base_10, data_line, data_line_index, number, parse_good);
    IF NOT parse_good THEN
      dpp$display_error ('*ERROR* Fourth parameter is invalid.');
      RETURN;
    IFEND;

    IF (number >= 0) AND (number <= UPPERVALUE(cmt$physical_unit_number)) THEN
      unit := number;
    ELSE
      dpp$display_error ('*ERROR* Unit number out of range.');
      RETURN;
    IFEND;

    parse_number (c$base_10, data_line, data_line_index, number, parse_good);
    IF NOT parse_good THEN
      dpp$display_error ('*ERROR* Fifth parameter is invalid.');
      RETURN;
    IFEND;

    IF (number >= 0) AND (number <= UPPERVALUE(iot$logical_unit)) THEN
      logical_unit := number;
    ELSE
      dpp$display_error ('*ERROR* Logical unit number out of range.');
      RETURN;
    IFEND;

    iop$down_disk_unit (pp, physical_channel, equipment, unit, logical_unit, down_status);
    IF NOT down_status.normal THEN
      dpp$display_error ('*ERROR* Bad status from IOP$DOWN_DISK_UNIT.');
    IFEND;

  PROCEND process_down_unit;

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

{ PURPOSE:
{   This procedure processes the 'DUMPJOB' command.  The format of the command is as follows:
{     DUMPJOB PARAMETER1 PARAMETER2
{       PARAMETER1 is the system supplied name or an AJL ordinal.
{       PARAMETER2 is the disposition of the output produced by this command.  The valid values are
{         (retain r), (printer p), and (retain_and_print rap).  The default value will be 'retain_and_print'
{         unless otherwise changed by a Set_System_Attribute command.

  PROCEDURE process_dumpjob
    (    data_line: t$command;
     VAR data_line_index {input, output} : t$command_length);

    VAR
      cell_p: ^cell,
      ijle_p: ^jmt$initiated_job_list_entry,
      ijlo: jmt$ijl_ordinal,
      job_index: integer,
      number: integer,
      parse_good: boolean,
      save_data_line_index: t$command_length,
      word: t$command,
      word_length: t$command_length;

    save_data_line_index := data_line_index;
    parse_number (c$base_10, data_line, data_line_index, number, parse_good);
    IF NOT parse_good THEN
      data_line_index := save_data_line_index;
      parse_word (data_line, data_line_index, word, word_length, parse_good);
      IF NOT parse_good THEN
        dpp$display_error ('*ERROR* First parameter is invalid.');
        RETURN;
      IFEND;
      jmp$find_jsn (word (1, word_length), ijle_p, ijlo);
      IF ijle_p = NIL THEN
        dpp$display_error ('*ERROR* The system supplied name was not found.');
        RETURN;
      IFEND;

    ELSE
      job_index := number;
      cell_p := ^mtv$monitor_segment_table;
      #purge_buffer (osc$pva_purge_segment_cache, cell_p);
      IF (job_index <= UPPERBOUND (jmv$ajl_p^)) AND (mtv$monitor_segment_table.st [mtc$job_fixed_segment +
            job_index].ste.vl >= osc$vl_regular_segment) THEN
        ijle_p := jmv$ajl_p^ [job_index].ijle_p;
      ELSE
        dpp$display_error ('*ERROR* Cannot dump specified job.');
        RETURN;
      IFEND;
    IFEND;

    IF jmf$ijle_p (jmv$system_ijl_ordinal) = ijle_p THEN
      dpp$display_error ('*ERROR* Cannot DUMPJOB the system job.');
      RETURN;
    IFEND;

    { Display an informative message if the job is not swapped in.

    IF ijle_p^.entry_status >= jmc$ies_job_swapped THEN
      dpp$display_error (' Operator must SWAPIN job before DUMPJOB can proceed.');
    IFEND;

    IF jmv$service_classes [ijle_p^.job_scheduler_data.service_class]^.attributes.maximum_active_jobs = 0 THEN
      dpp$display_error (' MAXAJ for service class must be > 0 before DUMPJOB can proceed.');
    IFEND;

    parse_word (data_line, data_line_index, word, word_length, parse_good);
    IF NOT parse_good THEN
      dpp$display_error ('*ERROR* Second parameter is invalid.');
      RETURN;
    IFEND;

    IF word_length = 0 THEN
      IF syv$dflt_debug_output_disposal.disposal = syc$dod_null THEN
        syv$debug_output_disposition := syc$dod_save_and_print;
      ELSE
        syv$debug_output_disposition := syv$dflt_debug_output_disposal.disposal;
      IFEND;
    ELSEIF (word = 'RETAIN_AND_PRINT') OR (word = 'RAP') THEN
      syv$debug_output_disposition := syc$dod_save_and_print;
    ELSEIF (word = 'RETAIN') OR (word = 'R') THEN
      syv$debug_output_disposition := syc$dod_save_on_pf;
    ELSEIF (word = 'PRINTER') OR (word = 'P') THEN
      syv$debug_output_disposition := syc$dod_write_for_print;
    ELSEIF (word = 'CONSOLE') OR (word = 'C') THEN
      dpp$display_error ('*ERROR* Cannot DUMPJOB to the system console.');
      RETURN;
    ELSE
      dpp$display_error ('*ERROR* Second parameter is invalid.');
      RETURN;
    IFEND;

    tmp$monitor_flag_job_tasks (syc$mf_dump_job_environment, ijle_p);

  PROCEND process_dumpjob;

?? TITLE := ' process_enable_allocation', EJECT ??
{ PURPOSE:
{   This procedure processes the 'ENABLE_ALLOCATION' command.  The format of the command is as follows:
{     ENABLE_ALLOCATION PARAMETER1
{       PARAMETER1 is the AVT index.
{
{ NOTE:
{   This command is intended for testing purposes only.
{

  PROCEDURE process_enable_allocation
    (    data_line: t$command;
     VAR data_line_index {input, output} : t$command_length);

    VAR
      avti: integer,
      number: integer,
      parse_good: boolean;

    parse_number (c$base_10, data_line, data_line_index, number, parse_good);
    IF NOT parse_good THEN
      dpp$display_error ('*ERROR* First parameter is invalid.');
      RETURN;
    IFEND;

    IF (number > 0) AND (number <= UPPERBOUND (dmv$active_volume_table.table_p^)) THEN
      avti := number;
    ELSE
      dpp$display_error ('*ERROR* AVT index out of range.');
      RETURN;
    IFEND;

    IF dmv$active_volume_table.table_p^ [avti].entry_available THEN
      dpp$display_error ('*ERROR* Specified volume not active.');
    ELSE
      dmv$active_volume_table.table_p^ [avti].mass_storage.previous_allocation_allowed :=
            dmv$active_volume_table.table_p^ [avti].mass_storage.allocation_allowed;
      dmv$active_volume_table.table_p^ [avti].mass_storage.allocation_allowed := TRUE;
    IFEND;

  PROCEND process_enable_allocation;

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

{ PURPOSE:
{   This procedure processes the 'IDLE_SYSTEM' command.  The format of the command is as follows:
{     IDLE_SYSTEM

  PROCEDURE process_idle_system;

    VAR
      status: syt$monitor_status;

    IF mtv$scb.nos_180_status.system_status.idle_status_block.actual_status = mtc$running_system THEN
      IF mtv$scb.nos_180_status.system_status.step_status_block.actual_status = mtc$unstepped_system THEN
        mtv$scb.nos_180_status.system_status.idle_status_block.requested_status := mtc$idled_system;
        IF mtv$scb.nos_180_status.cause_of_idle = syc$ic_null THEN
          mtv$scb.nos_180_status.cause_of_idle := syc$ic_idle_command;
        IFEND;
        dpp$display_error ('Initiating IDLE_SYSTEM sequence.');
        tmp$monitor_ready_system_task (tmc$stid_job_monitor, status);
      ELSE
        dpp$display_error ('*ERROR* System already stepped.');
      IFEND;
    ELSE
      dpp$display_error ('*ERROR* System already idled.');
    IFEND;

  PROCEND process_idle_system;
?? OLDTITLE ??
?? NEWTITLE := 'process_password', EJECT ??

{ PURPOSE:
{   This procedure processes the password and finishes executing the disable_main_operator_window command and
{   the enable_main_operator_window command.

  PROCEDURE process_password
    (    password: string (7));

    VAR
      signal: dst$signal_contents,
      status: syt$monitor_status;

    v$expecting_password := FALSE;
    dpv$secure_input_line.secure := FALSE;
    signal.identifier := dsc$deadstart_signal;
    signal.contents.kind := dsc$signal_lock_unlock_window;
    signal.contents.luw_data.password := password;
    signal.contents.luw_data.lock_window := v$lock_main_window;
    tmp$send_signal (tmv$system_job_monitor_gtid, signal.signal, status);
    IF NOT status.normal THEN
      dpp$display_error ('Unable to enable the main operator window, problems sending signal.');
    IFEND;

  PROCEND process_password;
?? OLDTITLE ??
?? NEWTITLE := 'process_reset_memory_attributes', EJECT ??

{ PURPOSE:
{   This procedure processes the 'PROCESS_RESET_MEMORY_ATTRIBUTES' command.
{   The command has no parameters
{
{ NOTE: We could make it more sophisticated by getting the actual values during DS (as MANM).

  PROCEDURE process_reset_memory_attributes;

    VAR
      ma_index: mmt$mmu_memory_attributes,
      queue_id: mmt$page_frame_queue_id,
      source_q_p: ^mmt$global_page_queue_list_ent,
      target_q_p: ^mmt$global_page_queue_list_ent;

{Reset the Qs
    FOR queue_id := mmc$pq_shared_first TO mmc$pq_shared_last DO
      target_q_p := ^mmv$gpql [queue_id];
      source_q_p := ^mmv$manage_memory_utility.gpql [queue_id];

      target_q_p^.queue_age_interval := source_q_p^.queue_age_interval;
      target_q_p^.encrease_min_enable_dynamic_age := source_q_p^.encrease_min_enable_dynamic_age;

      target_q_p^.age_interval_nominal_modified := source_q_p^.age_interval_nominal_modified;
      target_q_p^.age_interval_nominal_unmodified := source_q_p^.age_interval_nominal_unmodified;
      target_q_p^.age_interval_modified_max := source_q_p^.age_interval_modified_max;
      target_q_p^.age_interval_modified_min := source_q_p^.age_interval_modified_min;
      target_q_p^.age_interval_unmodified_max := source_q_p^.age_interval_unmodified_max;
      target_q_p^.age_interval_unmodified_min := source_q_p^.age_interval_unmodified_min;
      target_q_p^.age_interval_neg_inc_modified := source_q_p^.age_interval_neg_inc_modified;
      target_q_p^.age_interval_neg_inc_unmodified := source_q_p^.age_interval_neg_inc_unmodified;
      target_q_p^.age_interval_pos_inc_modified := source_q_p^.age_interval_pos_inc_modified;
      target_q_p^.age_interval_pos_inc_unmodified := source_q_p^.age_interval_pos_inc_unmodified;

      target_q_p^.minimum_nominal := source_q_p^.minimum_nominal;
      target_q_p^.minimum_min := source_q_p^.minimum_min;
      target_q_p^.minimum_max := source_q_p^.minimum_max;
      target_q_p^.minimum_neg_inc := source_q_p^.minimum_neg_inc;
      target_q_p^.minimum_neg_inc_pc := source_q_p^.minimum_neg_inc_pc;
      target_q_p^.minimum_pos_inc := source_q_p^.minimum_pos_inc;
      target_q_p^.minimum_pos_inc_pc := source_q_p^.minimum_pos_inc_pc;

      target_q_p^.maximum_nominal := source_q_p^.maximum_nominal;
      target_q_p^.maximum_min := source_q_p^.maximum_min;
      target_q_p^.maximum_max := source_q_p^.maximum_max;
      target_q_p^.maximum_neg_inc := source_q_p^.maximum_neg_inc;
      target_q_p^.maximum_neg_inc_pc := source_q_p^.maximum_neg_inc_pc;
      target_q_p^.maximum_pos_inc := source_q_p^.maximum_pos_inc;
      target_q_p^.maximum_pos_inc_pc := source_q_p^.maximum_pos_inc_pc;

      target_q_p^.age_cycles := source_q_p^.age_cycles;

{dynamic aging values
      target_q_p^.age_interval_actual_modified := source_q_p^.age_interval_actual_modified;
      target_q_p^.age_interval_actual_unmodified := source_q_p^.age_interval_actual_unmodified;
      target_q_p^.minimum_actual := source_q_p^.minimum_actual;
      target_q_p^.maximum_actual := source_q_p^.maximum_actual;
      target_q_p^.maximum_actual_cycle := source_q_p^.maximum_actual;
    FOREND;

{Reset the Attributes
    FOR ma_index := LOWERBOUND (mmv$manage_memory_utility.ma) TO UPPERBOUND (mmv$manage_memory_utility.ma) DO
      IF mmv$manage_memory_utility.ma [ma_index].value_type = mmc$mmu_mvt_integer THEN
        mmv$manage_memory_utility.ma [ma_index].integer_p^ := mmv$manage_memory_utility.ma [ma_index].default;
      ELSE { mmc$mmu_mvt_byte }
        mmv$manage_memory_utility.ma [ma_index].byte_p^ := mmv$manage_memory_utility.ma [ma_index].default;
      IFEND;
    FOREND;

  PROCEND process_reset_memory_attributes;
?? OLDTITLE ??
?? NEWTITLE := 'process_resume_system', EJECT ??

{ PURPOSE:
{   This procedure processes the 'RESUME_SYSTEM' command.  The format of the command is as follows:
{     RESUME_SYSTEM

  PROCEDURE process_resume_system;

    VAR
      scb_hardware_status: mtt$scb_trick_variant_record;

    IF mtv$scb.nos_180_status.system_status.idle_status_block.actual_status = mtc$idled_system THEN
      scb_hardware_status.hardware_status := mtv$scb.hardware_status;
      IF scb_hardware_status.errors_present = 0 THEN
        IF (mtv$scb.nos_180_status.idle_code = syc$ic_idle_command) OR

          { Code deactivated until we REALLY can do this.
          {   (mtv$scb.nos_180_status.idle_code = syc$ic_hardware_idle) OR

              (mtv$scb.nos_180_status.idle_code = syc$ic_long_power) THEN
          mtv$scb.nos_180_status.system_status.idle_status_block.requested_status := mtc$running_system;
          mtv$scb.nos_180_status.system_status.step_status_block.requested_status := mtc$unstepped_system;
        ELSE
          dpp$display_error ('*ERROR* System cannot be resumed via console command.');
        IFEND;
      ELSE
        dpp$display_error ('*ERROR* System cannot be resumed while hardware problems exist.');
      IFEND;
    ELSEIF mtv$scb.nos_180_status.system_status.step_status_block.actual_status = mtc$stepped_system THEN
      dpp$display_error ('*ERROR* System stepped. Only UNSTEP_SYSTEM can restart system.');
    ELSE
      dpp$display_error ('*ERROR* System already running.');
    IFEND;

  PROCEND process_resume_system;
?? OLDTITLE ??
?? NEWTITLE := 'process_step_system', EJECT ??

{ PURPOSE:
{   This procedure processes the 'STEP_SYSTEM' command.  The format of the command is as follows:
{     STEP_SYSTEM

  PROCEDURE process_step_system;

    IF mtv$scb.nos_180_status.system_status.step_status_block.actual_status = mtc$unstepped_system THEN
      mtv$scb.nos_180_status.system_status.step_status_block.requested_status := mtc$stepped_system;
    ELSE
      dpp$display_error ('*ERROR* System already stepped.');
    IFEND;

  PROCEND process_step_system;
?? OLDTITLE ??
?? NEWTITLE := 'process_sysdebug', EJECT ??

{ PURPOSE:
{   This procedure processes the 'SYSDEBUG' command.  The format of the command is as follows:
{     SYSDEBUG PARAMETER1 PARAMETER2
{       PARAMETER1 is the system supplied name or an AJL ordinal.
{       PARAMETER2 is the (optional) parameter specifying whether ALL tasks of the job should be debugged or
{         just the $JOBMNTR task should be debugged.  The default is $JOBMNTR.

  PROCEDURE process_sysdebug
    (    data_line: t$command;
     VAR data_line_index {input, output} : t$command_length);

    VAR
      all_tasks: boolean,
      ijle_p: ^jmt$initiated_job_list_entry,
      ijlo: jmt$ijl_ordinal,
      job_index: integer,
      job_monitor_id: ost$global_task_id,
      monitor_status: syt$monitor_status,
      parse_good: boolean,
      save_data_line_index: t$command_length,
      test_ijle_p: ^jmt$initiated_job_list_entry,
      use_computed_ijle_p: boolean,
      word: t$command,
      word_length: t$command_length;

    use_computed_ijle_p := FALSE;
    save_data_line_index := data_line_index;
    job_index := 0;

    parse_number (c$base_10, data_line, data_line_index, job_index, parse_good);
    IF NOT parse_good THEN
      data_line_index := save_data_line_index;
      parse_word (data_line, data_line_index, word, word_length, parse_good);
      IF NOT parse_good THEN
        dpp$display_error ('*ERROR* First parameter is invalid.');
        RETURN;
      IFEND;

      jmp$find_jsn (word (1, word_length), ijle_p, ijlo);
      IF ijle_p <> NIL THEN
        use_computed_ijle_p := TRUE;
      ELSE
        dpp$display_error ('*ERROR* The system supplied name was not found.');
        RETURN;
      IFEND;
    IFEND;

    parse_word (data_line, data_line_index, word, word_length, parse_good);
    IF NOT parse_good THEN
      dpp$display_error ('*ERROR* Second parameter is invalid.');
      RETURN;
    IFEND;

    IF (word_length = 0) OR (word = '$JOBMNTR') THEN
      all_tasks := FALSE;
    ELSEIF word = 'ALL' THEN
      all_tasks := TRUE;
    ELSE
      dpp$display_error ('*ERROR* Second parameter is invalid.');
      RETURN;
    IFEND;

    IF NOT use_computed_ijle_p THEN
      IF (job_index = jmv$system_ajl_ordinal) AND all_tasks THEN
        dpp$display_error ('*ERROR* Cannot debug all tasks in system job');
        RETURN;
      IFEND;
      IF (job_index <= UPPERBOUND (jmv$ajl_p^)) AND (jmv$ajl_p^ [job_index].in_use <> 0) THEN
        ijle_p := jmv$ajl_p^ [job_index].ijle_p;
      ELSE
        dpp$display_error ('*ERROR* Job not active');
        RETURN;
      IFEND;
    IFEND;

    { Display an informative message if the job is not swapped in.

    IF ijle_p^.entry_status = jmc$ies_operator_force_out THEN
      dpp$display_error (' Operator must SWAPIN job before SYSDEBUG can proceed.');
    IFEND;

    IF all_tasks THEN
      IF jmf$ijle_p (jmv$system_ijl_ordinal) = ijle_p THEN
        dpp$display_error ('*ERROR* Cannot debug all tasks in the system job.');
        RETURN;
      IFEND;
      syv$debug_output_disposition := syc$dod_null;
      tmp$monitor_flag_job_tasks (syc$mf_invoke_sysdebug, ijle_p);
    ELSE
      job_monitor_id := ijle_p^.job_monitor_taskid;
      syv$debug_output_disposition := syc$dod_null;
      tmp$set_monitor_flag (job_monitor_id, syc$mf_invoke_sysdebug, monitor_status);
    IFEND;

  PROCEND process_sysdebug;
?? OLDTITLE ??
?? NEWTITLE := 'process_tdebug', EJECT ??

{ PURPOSE:
{   This procedure processes the 'TDEBUG' command.  The format of the command is as follows:
{     TDEBUG GLOBAL_TASK_ID

  PROCEDURE process_tdebug
    (    data_line: t$command;
     VAR data_line_index {input, output} : t$command_length);

    VAR
      global_task_id: ost$global_task_id,
      index: integer,
      monitor_status: syt$monitor_status,
      mult: integer,
      number: integer,
      parse_good: boolean;

    parse_number (c$base_16, data_line, data_line_index, number, parse_good);
    IF NOT parse_good THEN
      dpp$display_error ('*ERROR* First parameter is invalid.');
      RETURN;
    IFEND;

    mult := 1;
    FOR index := 1 TO #SIZE (global_task_id.seqno) DO
      mult := mult * 256;
    FOREND;

    IF (number DIV mult) > 65535 THEN
      dpp$display_error ('*ERROR* Invalid Task Id.');
      RETURN;
    IFEND;

    global_task_id.index := number DIV mult;
    IF (number MOD mult) <= UPPERVALUE (global_task_id.seqno) THEN
      global_task_id.seqno := number MOD mult;
      syv$debug_output_disposition := syc$dod_null;
      tmp$set_monitor_flag (global_task_id, syc$mf_invoke_sysdebug, monitor_status);
      IF NOT monitor_status.normal THEN
        dpp$display_error ('*ERROR* Invalid Task Id.');
      IFEND;
    IFEND;

  PROCEND process_tdebug;
?? OLDTITLE ??
?? NEWTITLE := 'process_unstep_system', EJECT ??

{ PURPOSE:
{   This procedure processes the 'UNSTEP_SYSTEM' command.  The format of the command is as follows:
{     UNSTEP_SYSTEM

  PROCEDURE process_unstep_system;

    VAR
      scb_hardware_status: mtt$scb_trick_variant_record;

    IF mtv$scb.nos_180_status.system_status.step_status_block.actual_status = mtc$stepped_system THEN
      IF mtv$scb.nos_180_status.system_status.idle_status_block.actual_status = mtc$running_system THEN
        scb_hardware_status.hardware_status := mtv$scb.hardware_status;
        IF scb_hardware_status.errors_present = 0 THEN
          IF (mtv$scb.nos_180_status.idle_code = syc$ic_step_command) OR
                (mtv$scb.nos_180_status.idle_code = syc$ic_short_power) OR
                (mtv$scb.nos_180_status.idle_code = syc$ic_disk_error) OR
                (mtv$scb.nos_180_status.idle_code = syc$ic_software_breakpoint) THEN
            mtv$scb.nos_180_status.system_status.step_status_block.requested_status := mtc$unstepped_system;
          ELSE
            dpp$display_error ('*ERROR* System cannot be unstepped via console command.');
          IFEND;
        ELSE
          dpp$display_error ('*ERROR* System cannot be unstepped while hardware problems exist.');
        IFEND;
      ELSEIF mtv$scb.nos_180_status.system_status.idle_status_block.requested_status = mtc$running_system THEN
        scb_hardware_status.hardware_status := mtv$scb.hardware_status;
        IF scb_hardware_status.errors_present = 0 THEN
          IF (mtv$scb.nos_180_status.idle_code = syc$ic_step_command) OR
                (mtv$scb.nos_180_status.idle_code = syc$ic_short_power) OR
                (mtv$scb.nos_180_status.idle_code = syc$ic_disk_error) OR
                (mtv$scb.nos_180_status.idle_code = syc$ic_software_breakpoint) THEN
            mtv$scb.nos_180_status.system_status.step_status_block.requested_status := mtc$unstepped_system;
          ELSE
            dpp$display_error ('*ERROR* System cannot be unstepped via console command.');
          IFEND;
        ELSE
          dpp$display_error ('*ERROR* System cannot be unstepped while hardware problems exist.');
        IFEND;
      ELSE
        dpp$display_error ('*ERROR* System idled. Only RESUME_SYSTEM can restart system.');
      IFEND;
    ELSE
      dpp$display_error ('*ERROR* System already unstepped.');
    IFEND;

  PROCEND process_unstep_system;
?? TITLE := 'process_sync', EJECT ??

{ PURPOSE:
{   This procedure processes the 'SYNC' command.  The format of the command is as follows:
{     SYNC PASSES TRAPS_ENABLED
{       passes - specifies the number of times the SYNC instruction will be called.  The default value is
{                zero.
{       traps_enabled - specifies whether traps are enabled or disabled during SYNC execution.  The default
{                       value is zero (disabled).

  PROCEDURE process_sync
    (    data_line: t$command;
     VAR data_line_index {input, output} : t$command_length);

    VAR
      index: integer,
      old_te: 0..3,
      passes: integer,
      parse_good: boolean,
      traps_enabled: integer;

    passes := 0;
    traps_enabled := 0;

    parse_number (c$base_16, data_line, data_line_index, passes, parse_good);
    IF NOT parse_good THEN
      dpp$display_error ('*ERROR* PASSES parameter is invalid.');
      RETURN;
    IFEND;

    IF passes <= 0 THEN
      RETURN;
    IFEND;

    parse_number (c$base_16, data_line, data_line_index, traps_enabled, parse_good);
    IF NOT parse_good THEN
      dpp$display_error ('*ERROR* TRAPS_ENABLED parameter is invalid.');
      RETURN;
    IFEND;

    IF (traps_enabled <> 0) AND (traps_enabled <> 1) THEN
      dpp$display_error ('*ERROR* Invalid Traps_Enabled value.');
      dpp$display_error ('*INFORMATIVE* 0 = traps disabled, 1 = traps enabled');
      RETURN;
    IFEND;

{ Traps are disabled by the caller of this procedure.  If traps are desired, enable/disable them.

    IF traps_enabled = 1 THEN
      i#mtr_enable_traps (old_te);
    IFEND;

    FOR index := 1 TO passes DO
      i#sync;
    FOREND;

    IF traps_enabled = 1 THEN
      i#mtr_disable_traps (old_te);
    IFEND;

  PROCEND process_sync;
?? OLDTITLE ??
?? NEWTITLE := 'dpp$process_monitor_command', EJECT ??

{ PURPOSE:
{   This procedure processes the monitor command and performs the appropriate action.

  PROCEDURE [XDCL] dpp$process_monitor_command
    (    input_line: string ( * ));

    VAR
      data_line: t$command,
      data_line_index: t$command_length,
      parse_good: boolean,
      word: t$command,
      word_length: t$command_length;

    IF NOT tmv$tables_initialized THEN
      dpp$display_error ('*ERROR* System not sufficiently initialized to accept commands');
      RETURN;
    IFEND;

    data_line := input_line;
    dpp$display_error (data_line (1, 71));
    data_line_index := 1;
    parse_word (data_line, data_line_index, word, word_length, parse_good);

    IF v$expecting_password THEN
      process_password (word (1, 7));
      RETURN;
    ELSEIF (word_length = 0) AND parse_good THEN
      RETURN;
    ELSEIF NOT parse_good THEN
      dpp$display_error ('*ERROR* Invalid monitor command');
      RETURN;
    IFEND;

    IF word = '"' THEN {ignore the command as comment - a special request from W. Rietmann.
      RETURN;
    ELSEIF word = 'HELP' THEN
      dpp$display_error ('Monitor Commands:');
      dpp$display_error ('  CHANGE_MDD_OPERATING_MODE    ON/OFF,PORT_NUMBER');
      dpp$display_error ('  DISABLE_ALLOCATION AVT_Index - for testing purpose only.');
      dpp$display_error ('  DISABLE_MAIN_OPERATOR_WINDOW - see secure operation');
      dpp$display_error ('  DOWN_CHANNEL                 Logical_PP,Channel,Port_Letter');
      dpp$display_error ('  DOWN_CONTROLLER              Logical_PP,Channel,Equipment');
      dpp$display_error ('  DOWN_UNIT                    Logical_PP,CH,Equip,Unit,LUN');
      dpp$display_error ('  DUMPJOB                      SJN/AJL_Nr,Output (R, P, RAP)');
      dpp$display_error ('  ENABLE_ALLOCATION AVT_Index  - for testing purpose only.');
      dpp$display_error ('  ENABLE_MAIN_OPERATOR_WINDOW  - see secure operation');
      dpp$display_error ('  IDLE_SYSTEM');
      dpp$display_error ('  RESET_MEMORY_ATTRIBUTES');
      dpp$display_error ('  RESUME_SYSTEM');
      dpp$display_error ('  STEP_SYSTEM');
      dpp$display_error ('  SYSDEBUG                     SJN/AJL_Nr,(ALL/$JOBMTR)');
      dpp$display_error ('  TDEBUG                       Global_Task_ID');
      dpp$display_error ('  UNSTEP_SYSTEM');
      dpp$display_error ('  VOLUME_AVAILABLE             - for testing purpose only');
      dpp$display_error ('  SYNC                         #Passes,Traps (0=Dis/1=Enab)');
      RETURN;
    ELSEIF word = 'CHANGE_MDD_OPERATING_MODE' THEN
      IF avv$security_options [avc$vso_secure_analysis].active THEN
        dpp$display_error ('*ERROR* MDD call ignored, it was disabled at deadstart.');
      ELSE
        process_change_mdd_op_mode (data_line, data_line_index);
      IFEND;
    ELSEIF word = 'DISABLE_ALLOCATION' THEN
      process_disable_allocation (data_line, data_line_index);
    ELSEIF word = 'DISABLE_MAIN_OPERATOR_WINDOW' THEN
      process_dismow_enamow (TRUE);
    ELSEIF word = 'DOWN_CHANNEL' THEN
      process_down_channel (data_line, data_line_index);
    ELSEIF word = 'DOWN_CONTROLLER' THEN
      process_down_controller (data_line, data_line_index);
    ELSEIF word = 'DOWN_UNIT' THEN
      process_down_unit (data_line, data_line_index);
    ELSEIF word = 'DUMPJOB' THEN
      IF avv$security_options [avc$vso_secure_analysis].active THEN
        dpp$display_error ('*ERROR* DUMPJOB call ignored, it was disabled at deadstart.');
      ELSE
        process_dumpjob (data_line, data_line_index);
      IFEND;
    ELSEIF word = 'ENABLE_ALLOCATION' THEN
      process_enable_allocation (data_line, data_line_index);
    ELSEIF word = 'ENABLE_MAIN_OPERATOR_WINDOW' THEN
      process_dismow_enamow (FALSE);
    ELSEIF word = 'IDLE_SYSTEM' THEN
      process_idle_system;
    ELSEIF word = 'RESET_MEMORY_ATTRIBUTES' THEN
      process_reset_memory_attributes;
    ELSEIF word = 'RESUME_SYSTEM' THEN
      process_resume_system;
    ELSEIF word = 'STEP_SYSTEM' THEN
      process_step_system;
    ELSEIF word = 'SYSDEBUG' THEN
      IF avv$security_options [avc$vso_secure_analysis].active THEN
        dpp$display_error ('*ERROR* SYSDEBUG call ignored, it was disabled at deadstart.');
      ELSE
        process_sysdebug (data_line, data_line_index);
      IFEND;
    ELSEIF word = 'TDEBUG' THEN
      IF avv$security_options [avc$vso_secure_analysis].active THEN
        dpp$display_error ('*ERROR* TDEBUG call ignored, it was disabled at deadstart.');
      ELSE
        process_tdebug (data_line, data_line_index);
      IFEND;
    ELSEIF word = 'UNSTEP_SYSTEM' THEN
      process_unstep_system;
    ELSEIF word = 'VOLUME_AVAILABLE' THEN      {This command is for development testing ONLY!!
      mmp$volume_available;
      jmp$resurrect_dead_jobs;
    ELSEIF word = 'SYNC' THEN
      process_sync (data_line, data_line_index);
    ELSE
      dpp$display_error ('*ERROR* Invalid monitor command.');
    IFEND;

  PROCEND dpp$process_monitor_command;
MODEND dpm$process_monitor_command;
