?? LEFT := 1, RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE Command Language : Command Processor for display_system_task_data' ??
MODULE clm$display_system_task_data;

{ PURPOSE:
{   This module contains the command processor for the command DISPLAY_SYSTEM_TASK_DATA.

?? NEWTITLE := 'Global Declarations Referenced by this Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc clt$parameter_list
*copyc jme$queued_file_conditions
*copyc osc$processor_defined_registers
*copyc ost$status
?? POP ??
*copyc clp$build_standard_title
*copyc clp$close_display
*copyc clp$convert_integer_to_string
*copyc clp$evaluate_parameters
*copyc clp$new_display_line
*copyc clp$open_display_reference
*copyc clp$put_display
*copyc clp$reset_for_next_display_page
*copyc clv$nil_display_control
*copyc osp$establish_block_exit_hndlr
*copyc osp$disestablish_cond_handler
*copyc osp$get_system_task_data
*copyc osp$set_status_abnormal
?? OLDTITLE, NEWTITLE := '[XDCL, #GATE] clp$display_system_task_command', EJECT ??

  PROCEDURE [XDCL, #GATE] clp$display_system_task_command (parameter_list: clt$parameter_list;
    VAR status: ost$status);

{   PROCEDURE (osm$disstd) display_system_task_data, disstd (
{     task_name, task_names, tn:
{       any of
{         key
{           all
{         keyend
{         list of name
{       anyend = all
{     display_option, do:
{       key
{        (brief, b)
{        (full, f)
{       keyend = brief
{     output, o: file = $output
{     status)

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

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 8] of clt$pdt_parameter_name,
      parameters: array [1 .. 4] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 1] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$list_type_qualifier,
          element_type_spec: record
            header: clt$type_specification_header,
            qualifier: clt$name_type_qualifier,
          recend,
        recend,
        default_value: string (3),
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 4] of clt$keyword_specification,
        default_value: string (5),
      recend,
      type3: record
        header: clt$type_specification_header,
        default_value: string (7),
      recend,
      type4: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [89, 7, 31, 14, 6, 11, 369],
    clc$command, 8, 4, 0, 0, 0, 0, 4, 'OSM$DISSTD'], [
    ['DISPLAY_OPTION                 ',clc$nominal_entry, 2],
    ['DO                             ',clc$abbreviation_entry, 2],
    ['O                              ',clc$abbreviation_entry, 3],
    ['OUTPUT                         ',clc$nominal_entry, 3],
    ['STATUS                         ',clc$nominal_entry, 4],
    ['TASK_NAME                      ',clc$nominal_entry, 1],
    ['TASK_NAMES                     ',clc$alias_entry, 1],
    ['TN                             ',clc$abbreviation_entry, 1]],
    [
{ PARAMETER 1
    [6, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 85, clc$optional_default_parameter, 0, 3],
{ PARAMETER 2
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 155, clc$optional_default_parameter, 0, 5],
{ PARAMETER 3
    [4, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 3, clc$optional_default_parameter, 0, 7],
{ PARAMETER 4
    [5, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation,
  clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$union_type], [[clc$keyword_type,
    clc$list_type],
    FALSE, 2],
    44, [[1, 0, clc$keyword_type], [1], [
      ['ALL                            ', clc$nominal_entry,
  clc$normal_usage_entry, 1]]
      ],
    21, [[1, 0, clc$list_type], [5, 1, clc$max_list_size, FALSE],
        [[1, 0, clc$name_type], [1, osc$max_name_size]]
      ]
    ,
    'all'],
{ PARAMETER 2
    [[1, 0, clc$keyword_type], [4], [
    ['B                              ', clc$abbreviation_entry,
  clc$normal_usage_entry, 1],
    ['BRIEF                          ', clc$nominal_entry,
  clc$normal_usage_entry, 1],
    ['F                              ', clc$abbreviation_entry,
  clc$normal_usage_entry, 2],
    ['FULL                           ', clc$nominal_entry,
  clc$normal_usage_entry, 2]]
    ,
    'brief'],
{ PARAMETER 3
    [[1, 0, clc$file_type],
    '$output'],
{ PARAMETER 4
    [[1, 0, clc$status_type]]];

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

    CONST
      p$task_name = 1,
      p$display_option = 2,
      p$output = 3,
      p$status = 4;

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

    VAR
      ignore_status: ost$status;

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

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

      clp$close_display (display_control, ignore_status);
      handler_status.normal := TRUE;

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

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

      { This command does not produce subtitles. This procedure is declared
      { for consistancy and to provide a no-op for calls to this procedure.

      status.normal := TRUE;

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

    PROCEDURE format_system_task_data (
          criteria: ost$system_task_data_criteria;
          display_all_info: boolean;
      VAR display_control: clt$display_control;
      VAR status: ost$status);

      VAR
        i: integer,
        length: integer,
        s: string (80),
        system_task_count: integer,
        system_task_data: ^ost$system_task_display_data,
        temp: string(9);

      system_task_count := 1;
      REPEAT
        PUSH system_task_data: [1 .. system_task_count];
        osp$get_system_task_data (criteria, system_task_data^, system_task_count, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
      UNTIL system_task_count <= UPPERBOUND (system_task_data^);
      FOR i := 1 TO system_task_count DO
        s := '  ';
        s (1, *) := system_task_data^[i].task_name;
        IF display_all_info THEN
          IF system_task_data^[i].automatic_restart THEN
            s (34) := 'T';
          ELSE
            s (34) := 'F';
          IFEND;
          IF system_task_data^[i].deactivate_task_option = osc$tt_terminate THEN
            s (39) := 'T';
          ELSEIF system_task_data^[i].deactivate_task_option = osc$tt_voluntary THEN
            s (39) := 'V';
          ELSE { system_task_data^[i].deactivate_task_option = osc$tt_ignore_or_prohibited }
            s (39) := 'P';
          IFEND;
          IF system_task_data^[i].idle_task_option = osc$tt_terminate THEN
            s (43) := 'T';
          ELSEIF system_task_data^[i].idle_task_option = osc$tt_voluntary THEN
            s (43) := 'V';
          ELSE { system_task_data^[i].idle_task_option = osc$tt_ignore_or_prohibited }
            s (43) := 'I';
          IFEND;
          IF system_task_data^[i].restart_after_idle THEN
            s (48) := 'T';
          ELSE
            s (48) := 'F';
          IFEND;
          STRINGREP (s (52,3), length, system_task_data^[i].spy_identifier);
          STRINGREP (s (56,4), length, system_task_data^[i].execution_ring);
          IF system_task_data^[i].active THEN
            s (62) := 'T';
          ELSE
            s (62) := 'F';
          IFEND;
          IF system_task_data^[i].task_status.complete THEN
            s (68) := 'T';
            IF system_task_data^[i].task_status.status.normal THEN
              s (71, *) := '  Normal';
            ELSE
              s (71) := $CHAR((system_task_data^[i].task_status.status.condition DIV 1000000(16))
                    DIV 100(16));
              s (72) := $CHAR((system_task_data^[i].task_status.status.condition DIV 1000000(16))
                    MOD 100(16));
              STRINGREP (temp, length, (system_task_data^[i].task_status.status.condition
                    MOD 1000000(16)));
              s (73, length - 1) := temp (2, length - 1)
            IFEND;
          ELSE
            s (68) := 'F';
          IFEND;
        IFEND; { display all information }
        clp$put_display (display_control, s, clc$trim, status);
        IF NOT status.normal THEN
          RETURN;
        IFEND;
      FOREND;
    PROCEND format_system_task_data;
?? OLDTITLE, EJECT ??
    VAR
      criteria: ost$system_task_data_criteria,
      default_ring_attributes: amt$ring_attributes,
      display_all_info: boolean,
      display_control: clt$display_control,
      node: ^clt$data_value,
      s: string (80);

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

    criteria.all_tasks := pvt [p$task_name].value^.kind = clc$keyword;
    display_all_info := pvt [p$display_option].value^.keyword_value = 'FULL';

{ Open the specified file and get it ready to accept output.

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

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

/display/
  BEGIN

{ Display header format:
{
{TASK NAME                      AUTO  OPTIONS: RE-  SPY      AC-  COM-  STATUS IF
{                               TERM   D   I   STRT ID  RING TIVE PLETE COMPLETE
{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx  T    t   t    T   xxx  xx   T     T   F #ZZZZZZ
{12345678901234567890123456789012345678901234567890123456789012345678901234567890
{         1         2         3         4         5         6         7         8

    s (1, *) := 'TASK NAME';
    IF display_all_info THEN
      s (32, *) := 'AUTO  OPTIONS: RE-  SPY      AC-  COM-  STATUS IF';
    IFEND;
    clp$put_display (display_control, s, clc$trim, status);
    IF NOT status.normal THEN
      EXIT /display/;
    IFEND;
    IF display_all_info THEN
      s := ' ';
      s (32, *) := 'TERM   D   I   STRT ID  RING TIVE PLETE COMPLETE ';
      clp$put_display (display_control, s, clc$trim, status);
      IF NOT status.normal THEN
        EXIT /display/;
      IFEND;
    IFEND;

    clp$new_display_line (display_control, 1, status);
    IF NOT status.normal THEN
      EXIT /display/;
    IFEND;

    IF criteria.all_tasks THEN
      format_system_task_data (criteria, display_all_info, display_control, status);
    ELSE
      node := pvt [p$task_name].value;
      WHILE node <> NIL DO
        criteria.task_name := node^.element_value^.name_value;
        format_system_task_data (criteria, display_all_info, display_control, status);
        IF NOT status.normal THEN
          EXIT /display/;
        IFEND;
        node := node^.link;
      WHILEND;
    IFEND;
  END /display/;

    IF status.normal THEN
      clp$close_display (display_control, status);
    ELSE
      clp$close_display (display_control, ignore_status);
    IFEND;

    osp$disestablish_cond_handler;

  PROCEND clp$display_system_task_command;
?? OLDTITLE ??
MODEND clm$display_system_task_data;
