?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE Interactive Facility: Default Condition Handler' ??
MODULE ifm$default_condition_handler;

{
{ PURPOSE:
{   This module contains the default handler for interactive conditions.
{

?? NEWTITLE := 'Global Declarations', EJECT ??
?? PUSH (LISTEXT := OFF) ??
*copyc ifc$interrupt
*copyc ife$error_codes
*copyc ift$condition_codes
*copyc ost$status
*copyc pmt$condition
?? POP ??
*copyc avp$ring_nominal
*copyc clp$get_processing_phase
*copyc clp$put_job_output
*copyc ifp$advance
*copyc ifp$begin_pause_utility
*copyc ifp$end_pause_utility
*copyc ifv$pause_utility_count
*copyc iip$report_status_error
*copyc jmp$system_job
*copyc osp$executing_in_job_monitor
*copyc osp$set_status_condition
*copyc pmp$dispose_interactive_cond
*copyc pmp$execute_with_less_privilege
*copyc pmp$log
*copyc jmp$system_job
?? TITLE := 'ifp$default_interactive_handler', EJECT ??

  PROCEDURE [XDCL] ifp$default_interactive_handler
    (    condition: pmt$condition;
     VAR status: ost$status);

    VAR
      local_status: ost$status;


    status.normal := TRUE;

    IF condition.interactive_condition = ifc$terminate_break THEN
      pmp$log (' processing terminate break condition', local_status);
      IF osp$executing_in_job_monitor () THEN
        IF NOT jmp$system_job () THEN
          ifp$advance (1, ifc$advance_all_queued_output, local_status);
        IFEND;
        pmp$log (' terminate break in $JOBMNTR ignored', local_status);
      ELSE
        osp$set_status_condition (ife$terminate_break_received, status);
      IFEND;
      RETURN;
    IFEND;

    IF condition.interactive_condition = ifc$terminal_connection_broken THEN

{ ignore this in default handler - tasks will hang on terminal io

      pmp$log (' disconnect ignored by default handler', local_status);
      RETURN;
    IFEND;

    IF condition.interactive_condition = ifc$interrupt THEN
      pmp$log (' Ifc$interrupt condition ignored by default handler', local_status);
      RETURN;
    IFEND;

    IF condition.interactive_condition = ifc$job_reconnect THEN
      clp$put_job_output (' Job has been reconnected to this terminal', local_status);
    IFEND;

{ treat pause break and terminal reconnect the same

{ ignore pause breaks if max are currently pending
{ (treat as though the pause break was handled)

    IF NOT jmp$system_job () THEN
      IF ifv$pause_utility_count = ifc$pause_utility_count_maximum THEN
        clp$put_job_output (' Pause break ignored - the nested pause break limit has been exceeded',
              local_status);
        RETURN;
      IFEND;
    IFEND;

{ start pause utility - pause break

    ifp$start_pause_utility (status);

    IF status.normal THEN
      pmp$log ('resume after break', local_status);
      RETURN;
    IFEND;

{ raise terminate condition within the task

    pmp$log (' terminate_command causing terminate condition', local_status);
    pmp$dispose_interactive_cond (ifc$terminate_break);
    status.normal := TRUE;

  PROCEND ifp$default_interactive_handler;
?? TITLE := 'ifp$start_pause_utility', EJECT ??

  PROCEDURE [XDCL, #GATE] ifp$start_pause_utility
    (VAR status: ost$status);

    VAR
      ignore_status: ost$status,
      pd: ^SEQ (REP 1 of pmt$program_attributes),
      ppa: ^pmt$program_attributes,
      params: SEQ (REP 1 of char),
      processing_phase: clt$processing_phase,
      tid: pmt$task_id,
      tsts: pmt$task_status;


    status.normal := TRUE;

    clp$get_processing_phase (processing_phase, ignore_status);

    IF (NOT jmp$system_job ()) AND ((processing_phase < clc$user_prolog_phase) OR
          (processing_phase > clc$user_epilog_phase)) THEN
      RETURN;
    IFEND;

    ifp$begin_pause_utility (ignore_status);

    PUSH pd;
    RESET pd;
    NEXT ppa IN pd;
    ppa^.contents := $pmt$prog_description_contents
          [pmc$starting_proc_specified, pmc$load_map_options_specified,
          pmc$term_error_level_specified, pmc$debug_mode_specified];
    ppa^.starting_procedure := 'IIP$PAUSE_UTILITY';
    ppa^.load_map_options := $pmt$load_map_options [pmc$no_load_map];
    ppa^.termination_error_level := pmc$warning_load_errors;
    ppa^.debug_mode := pmc$debug_mode_off;
    RESET pd;
    pmp$execute_with_less_privilege (avp$ring_nominal (), pd^, params,
          osc$wait, FALSE, tid, tsts, status);
    IF NOT status.normal THEN
      ifp$end_pause_utility (ignore_status);
      iip$report_status_error (status, 'execute pause util');
      RETURN;
    IFEND;
    status := tsts.status;

    ifp$end_pause_utility (ignore_status);

  PROCEND ifp$start_pause_utility;

MODEND ifm$default_condition_handler;
