?? RIGHT := 110 ??
MODULE clm$enable_redo_processor;

{
{ PURPOSE:
{   This module sets flags in the shared segment access file to notify
{   Redo (which must already be active as a FAP) that it needs to reload
{   its TDU module. This may be because the user had not terminal type
{   established at login or because the user has switched terminal types
{   midsession. The flags also allow changing the insert_mode and the
{   full_duplex settings of redo.

?? NEWTITLE := '  Global Declarations', EJECT ??
?? PUSH (LISTEXT := ON) ??
*copyc clp$scan_parameter_list
*copyc clp$get_value
*copyc clp$read_variable
*copyc amp$fetch
*copyc amp$get_segment_pointer
*copyc amp$open
*copyc amp$put_next
*copyc clp$scan_command_line
*copyc ost$status
*copyc pmp$abort
*copyc pmp$exit
?? POP ??

?? TITLE := 'clp$enable_redo', EJECT ??

  PROGRAM clp$enable_redo
    (    parameter_list: clt$parameter_list;
     VAR status: ost$status);

{PDT for clm$enable_redo_processor}

{ PDT enable_redo_pdt (
{ full_duplex, fd : boolean = no
{ insert_mode, im : boolean = no
{ STATUS)

?? PUSH (LISTEXT := ON) ??

    VAR
      enable_redo_pdt: [STATIC, READ, cls$pdt] clt$parameter_descriptor_table :=
            [^enable_redo_pdt_names, ^enable_redo_pdt_params];

    VAR
      enable_redo_pdt_names: [STATIC, READ, cls$pdt_names_and_defaults] array [1 .. 5] of
            clt$parameter_name_descriptor := [['FULL_DUPLEX', 1], ['FD', 1], ['INSERT_MODE', 2], ['IM', 2],
            ['STATUS', 3]];

    VAR
      enable_redo_pdt_params: [STATIC, READ, cls$pdt_parameters] array [1 .. 3] of
            clt$parameter_descriptor := [

{ FULL_DUPLEX FD }
      [[clc$optional_with_default, ^enable_redo_pdt_dv1], 1, 1, 1, 1, clc$value_range_not_allowed,
            [NIL, clc$boolean_value]],

{ INSERT_MODE IM }
      [[clc$optional_with_default, ^enable_redo_pdt_dv2], 1, 1, 1, 1, clc$value_range_not_allowed,
            [NIL, clc$boolean_value]],

{ STATUS }
      [[clc$optional], 1, 1, 1, 1, clc$value_range_not_allowed,
            [NIL, clc$variable_reference, clc$array_not_allowed, clc$status_value]]];

    VAR
      enable_redo_pdt_dv1: [STATIC, READ, cls$pdt_names_and_defaults] string (2) := 'no';

    VAR
      enable_redo_pdt_dv2: [STATIC, READ, cls$pdt_names_and_defaults] string (2) := 'no';

?? POP ??

{End of PDT}

    VAR
      ba: amt$file_byte_address,
      file_id: amt$file_identifier,
      full_duplex_on: ^boolean,
      full_duplex_value: clt$value,
      insert_mode_on: ^boolean,
      insert_mode_value: clt$value,
      lfn: amt$local_file_name,
      log_ptr: amt$segment_pointer,
      redo_not_established: [STATIC] string (80) :=
            'enable_command_redo must be in login prolog to allow post-login use.',
      reset_tdu: ^boolean,
      seg_file_id: amt$file_identifier;


    lfn := 'OUTPUT';
    amp$open (lfn, amc$record, NIL, file_id, status);
    IF NOT status.normal THEN
      pmp$abort (status);
    IFEND;

{Crack the command for the parameter values.}

    clp$scan_parameter_list (parameter_list, enable_redo_pdt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    clp$get_value ('FULL_DUPLEX', 1, 1, clc$low, full_duplex_value, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;
    clp$get_value ('INSERT_MODE', 1, 1, clc$low, insert_mode_value, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

{Setup the shared segment access file for inter-task communication.}

    lfn := 'clf$redo_log';
    amp$open (lfn, amc$segment, NIL, seg_file_id, status);
    IF NOT status.normal THEN
      amp$put_next (file_id, ^redo_not_established, 80, ba, status);
      pmp$abort (status);
    IFEND;
    amp$get_segment_pointer (seg_file_id, amc$sequence_pointer, log_ptr, status);
    IF NOT status.normal THEN
      amp$put_next (file_id, ^redo_not_established, 80, ba, status);
      pmp$abort (status);
    IFEND;

    NEXT reset_tdu IN log_ptr.sequence_pointer;
    NEXT full_duplex_on IN log_ptr.sequence_pointer;
    NEXT insert_mode_on IN log_ptr.sequence_pointer;
    IF full_duplex_value.bool.value THEN
      full_duplex_on^ := TRUE;
    ELSE
      full_duplex_on^ := FALSE;
    IFEND;
    IF insert_mode_value.bool.value THEN
      insert_mode_on^ := TRUE;
    ELSE
      insert_mode_on^ := FALSE;
    IFEND;
    reset_tdu^ := TRUE;
    status.normal := TRUE;
    pmp$exit (status);

  PROCEND clp$enable_redo;

MODEND clm$enable_redo_processor;
