?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE Dump Analyzer : Display Defaults Command' ??
MODULE dum$display_defaults;
?? RIGHT := 110 ??

{ PURPOSE:
{   This module contains the code for the display_defaults command.

?? NEWTITLE := 'Global Declarations Referenced by This Module', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc due$exception_condition_codes
?? POP ??
*copyc clp$close_display
*copyc clp$convert_integer_to_string
*copyc clp$evaluate_parameters
*copyc clp$open_display_reference
*copyc clp$put_display
*copyc dup$is_cpu1_installed
*copyc dup$new_page_procedure
*copyc osp$append_status_integer
*copyc osp$disestablish_cond_handler
*copyc osp$establish_block_exit_hndlr
*copyc osp$set_status_abnormal
?? EJECT ??
*copyc duv$default_parameters
*copyc duv$dump_environment_p
*copyc duv$execution_environment
*copyc duv$title_data
?? OLDTITLE ??
?? NEWTITLE := 'Global Declarations Declared by This Module', EJECT ??

  TYPE
    t$default_parameter_names = array [dut$default_parameters] of string (12);

  VAR
    v$default_parameter_names: t$default_parameter_names := ['address_mode', 'exchange', 'iou', 'pp_type',
          'processor'];

?? OLDTITLE ??
?? NEWTITLE := 'dup$display_defaults', EJECT ??

{ PURPOSE:
{   This procedure displays the current internal default values.

  PROCEDURE [XDCL] dup$display_defaults
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{ PROCEDURE display_defaults, disd (
{   display_option, display_options, do: any of
{       key
{         (all, a)
{         (last, l)
{       keyend
{       integer 1..clc$max_integer
{     anyend = last
{   output, o: file = $optional
{   title, t: string 1..31 = 'display_defaults'
{   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 .. 4] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$integer_type_qualifier,
        recend,
        default_value: string (4),
      recend,
      type2: record
        header: clt$type_specification_header,
      recend,
      type3: record
        header: clt$type_specification_header,
        qualifier: clt$string_type_qualifier,
        default_value: string (18),
      recend,
      type4: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [103, 5, 6, 12, 52, 41, 34],
    clc$command, 8, 4, 0, 0, 0, 0, 4, ''], [
    ['DISPLAY_OPTION                 ',clc$nominal_entry, 1],
    ['DISPLAY_OPTIONS                ',clc$alias_entry, 1],
    ['DO                             ',clc$abbreviation_entry, 1],
    ['O                              ',clc$abbreviation_entry, 2],
    ['OUTPUT                         ',clc$nominal_entry, 2],
    ['STATUS                         ',clc$nominal_entry, 4],
    ['T                              ',clc$abbreviation_entry, 3],
    ['TITLE                          ',clc$nominal_entry, 3]],
    [
{ PARAMETER 1
    [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, 195,
  clc$optional_default_parameter, 0, 4],
{ PARAMETER 2
    [5, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 3, clc$optional_parameter, 0
  , 0],
{ PARAMETER 3
    [8, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation, clc$standard_parameter_checking, 8,
  clc$optional_default_parameter, 0, 18],
{ PARAMETER 4
    [6, 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$integer_type, clc$keyword_type],
    FALSE, 2],
    155, [[1, 0, clc$keyword_type], [4], [
      ['A                              ', clc$abbreviation_entry, clc$normal_usage_entry, 1],
      ['ALL                            ', clc$nominal_entry, clc$normal_usage_entry, 1],
      ['L                              ', clc$abbreviation_entry, clc$normal_usage_entry, 2],
      ['LAST                           ', clc$nominal_entry, clc$normal_usage_entry, 2]]
      ],
    20, [[1, 0, clc$integer_type], [1, clc$max_integer, 10]]
    ,
    'last'],
{ PARAMETER 2
    [[1, 0, clc$file_type]],
{ PARAMETER 3
    [[1, 0, clc$string_type], [1, 31, FALSE],
    '''display_defaults'''],
{ PARAMETER 4
    [[1, 0, clc$status_type]]];

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

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

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

    TYPE
      t$cpu_line = record
        case boolean of
        = TRUE =
          line: string (31),
        = FALSE =
          unused_1: string (3),
          processor_string: string (9),
          unused_2: string (1),
          number: string (1),
          colon: string (1),
          unused_3: string (2),
          not_available: string (13),
        casend,
      recend,

      t$data_line = record
        case boolean of
        = TRUE =
          line: string (80),
        = FALSE =
          unused_1: string (5),
          default_name: string (26),
          unused_2: string (1),
          equal: string (1),
          unused_3: string (1),
          value: string (20),
          comment_dash: string (3),
          comment_int: string (7),
          comment: string (16),
        casend,
      recend,

      t$parameter_line = record
        case boolean of
        = TRUE =
          line: string (50),
        = FALSE =
          unused_1: string (3),
          parameter: string (12),
          unused_2: string (1),
          equal: string (1),
          unused_3: string (1),
          value: string (31),
        casend,
      recend;

    VAR
      cpu_line: t$cpu_line,
      data_line: t$data_line,
      default_counts: integer,
      displayed_default_counts: integer,
      display_control: clt$display_control,
      i: integer,
      ignore_status: ost$status,
      index: dut$default_parameters,
      integer_string: ost$string,
      next_p: ^dut$default_parameter_lists,
      output_display_opened: boolean,
      parameter_line: t$parameter_line,
      processor_index: 0 .. duc$de_maximum_processors,
      psm: dut$ee_psm_value,
      pta: dut$ee_pta_value,
      ptl: dut$ee_ptl_value,
      ring_attributes: amt$ring_attributes,
      title: string (80),
      title_length: integer;

*copy dup$abort_handler
?? NEWTITLE := 'clean_up', EJECT ??

{ PURPOSE:
{   This procedure is called from the abort handler to close the file.

    PROCEDURE [INLINE] clean_up;

      VAR
        ignore_status: ost$status;

      IF output_display_opened THEN
        clp$close_display (display_control, ignore_status);
      IFEND;

    PROCEND clean_up;
?? OLDTITLE ??
?? EJECT ??

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

    IF duv$dump_environment_p = NIL THEN
      osp$set_status_abnormal (duc$dump_analyzer_id, due$no_restart_file, '', status);
      RETURN; {---->
    IFEND;

    output_display_opened := FALSE;
    osp$establish_block_exit_hndlr (^abort_handler);

  /display_opened/
    BEGIN

      { Prepare the output display file.

      IF pvt [p$output].specified THEN
        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^, ^dup$new_page_procedure, fsc$list,
              ring_attributes, display_control, status);
        IF NOT status.normal THEN
          EXIT /display_opened/; {---->
        IFEND;
        output_display_opened := TRUE;
      ELSE
        display_control := duv$execution_environment.output_file.display_control;
        display_control.line_number := display_control.page_length + 1;
      IFEND;

      { Add to the main title.

      duv$title_data.build_title := TRUE;
      duv$title_data.command_name := pvt [p$title].value^.string_value^;
      clp$put_display (display_control, ' ', clc$trim, ignore_status);

      { Display the default values for the subcommand parameters.


      parameter_line.line := ' ';
      parameter_line.equal := '=';
      STRINGREP (title, title_length, ' Active subcommand parameter default values:');

      displayed_default_counts := 0;
      IF pvt [p$display_option].value^.kind = clc$integer THEN
        default_counts := pvt [p$display_option].value^.integer_value.value;
      ELSEIF pvt [p$display_option].value^.keyword_value = 'ALL' THEN
        default_counts := clc$max_integer;
      ELSE
        default_counts := 1;
      IFEND;

      next_p := duv$default_parameters;

      REPEAT
        clp$put_display (display_control, title (1, title_length), clc$no_trim, ignore_status);
        FOR index := LOWERBOUND (next_p^.value) TO UPPERBOUND (next_p^.value) DO
          parameter_line.parameter := v$default_parameter_names [index];
          IF next_p^.value [index].default_set THEN
            parameter_line.value := next_p^.value [index].value;
          ELSE
            parameter_line.value := 'no default set';
          IFEND;
          clp$put_display (display_control, parameter_line.line, clc$trim, ignore_status);
        FOREND;
        clp$put_display (display_control, ' ', clc$trim, ignore_status);
        next_p := next_p^.next_p;
        displayed_default_counts := displayed_default_counts + 1;
        STRINGREP (title, title_length, ' (', displayed_default_counts,
              ') Pushed subcommand parameter default values:');
      UNTIL (displayed_default_counts >= default_counts) OR (next_p = NIL);

      { Display the default values for the internal processor registers.

      clp$put_display (display_control, ' Internal processor register default values:', clc$trim,
            ignore_status);

    /process_register/
      FOR processor_index := 0 TO duc$de_maximum_processors DO
        cpu_line.line := ' ';
        cpu_line.processor_string := 'processor';
        clp$convert_integer_to_string (processor_index, 10, FALSE, integer_string, ignore_status);
        cpu_line.number := integer_string.value (1, integer_string.size);
        cpu_line.colon := ':';
        IF NOT duv$execution_environment.processor_registers [processor_index].available THEN
          cpu_line.not_available := 'not available';
          clp$put_display (display_control, cpu_line.line, clc$trim, ignore_status);
          dup$is_cpu1_installed (duc$ee_cic_disd, processor_index, display_control);
          CYCLE /process_register/; {---->
        ELSE
          clp$put_display (display_control, cpu_line.line, clc$trim, ignore_status);
        IFEND;

        data_line.line := ' ';
        data_line.equal := '=';

        data_line.default_name := 'job_process_state, jps';
        clp$convert_integer_to_string (duv$execution_environment.processor_registers [processor_index].
              job_process_state, 16, TRUE, integer_string, ignore_status);
        data_line.value := integer_string.value (1, integer_string.size);
        clp$put_display (display_control, data_line.line, clc$trim, ignore_status);

        data_line.default_name := 'monitor_process_state, mps';
        clp$convert_integer_to_string (duv$execution_environment.processor_registers [processor_index].
              monitor_process_state, 16, TRUE, integer_string, ignore_status);
        data_line.value := integer_string.value (1, integer_string.size);
        clp$put_display (display_control, data_line.line, clc$trim, ignore_status);

        data_line.default_name := 'page_size_mask, psm';
        psm.psm := duv$execution_environment.processor_registers [processor_index].page_size_mask;
        clp$convert_integer_to_string (psm.value, 16, TRUE, integer_string, ignore_status);
        data_line.value := integer_string.value (1, integer_string.size);
        i := 512 * (128 - psm.value);
        clp$convert_integer_to_string (i, 10, FALSE, integer_string, ignore_status);
        data_line.comment_dash := ' - ';
        data_line.comment_int := integer_string.value (1, integer_string.size);
        data_line.comment := ' Page_Size';
        clp$put_display (display_control, data_line.line, clc$trim, ignore_status);

        data_line.default_name := 'page_table_address, pta';
        pta.pta := duv$execution_environment.processor_registers [processor_index].page_table_address;
        clp$convert_integer_to_string (pta.value, 16, TRUE, integer_string, ignore_status);
        data_line.value := integer_string.value (1, integer_string.size);
        data_line.comment_dash := '';
        data_line.comment_int := '';
        data_line.comment := '';
        clp$put_display (display_control, data_line.line, clc$trim, ignore_status);

        data_line.default_name := 'page_table_length, ptl';
        ptl.ptl := duv$execution_environment.processor_registers [processor_index].page_table_length;
        clp$convert_integer_to_string (ptl.value, 16, TRUE, integer_string, ignore_status);
        data_line.value := integer_string.value (1, integer_string.size);
        i := 512 * (ptl.value + 1);
        clp$convert_integer_to_string (i, 10, FALSE, integer_string, ignore_status);
        data_line.comment_dash := ' - ';
        data_line.comment_int := integer_string.value (1, integer_string.size);
        data_line.comment := ' mmv$pt_length';
        clp$put_display (display_control, data_line.line, clc$trim, ignore_status);

      FOREND /process_register/;
    END /display_opened/;

    IF output_display_opened THEN
      clp$close_display (display_control, ignore_status);
    IFEND;
    osp$disestablish_cond_handler;

  PROCEND dup$display_defaults;
?? OLDTITLE ??
MODEND dum$display_defaults;
