?? RIGHT := 110 ??
?? NEWTITLE := 'NOS/VE Network Access: Miscellaneous Routines For Networks' ??
MODULE nam$miscellaneous;
?? NEWTITLE := 'Global Declarations Referenced by This Module' ??
?? PUSH (LISTEXT := ON) ??
*copyc i#call_monitor
*copyc oss$task_private
*copyc ifc$interrupt_timesharing_io
*copyc nac$namve_debug_mode
*copyc osc$job_recovery_condition_name
*copyc pfc$maximum_cycle_number
*copyc nae$namve_conditions
*copyc mmt$rb_idle_system
*copyc ost$caller_identifier
*copyc ost$status
?? POP ??
*copyc mmp$create_segment
*copyc mmp$delete_segment
*copyc osp$format_message
*copyc osp$is_caller_system_privileged
*copyc osp$recoverable_system_error
*copyc osp$set_status_abnormal
*copyc osp$set_status_from_condition
*copyc osp$system_error
*copyc osp$verify_system_privilege
*copyc pfp$find_cycle_array
*copyc pfp$find_direct_info_record
*copyc pfp$find_directory_array
*copyc pfp$find_next_info_record
*copyc pfp$get_item_info
*copyc pmp$log_ascii
*copyc syp$invoke_system_debugger
*copyc jmv$executing_within_system_job
*copyc mtv$halt_cpu_ring_number
*copyc nav$debug_mode
*copyc tmv$halt_on_hung_task

  VAR
    nav$cond_handler_trace_level: [XREF] 0 .. 0ff(16);

?? OLDTITLE ??
?? NEWTITLE := 'Global Declarations Declared by This Module' ??

{The following variable is currently for debuggin purpose to detect stacked handler calls.

  VAR
    nav$namve_tsk_hndl_active_count: [XDCL, #GATE, oss$task_private] integer := 0;

  CONST
    nac$network_ch_trace_buf_size = 19;

  VAR
    nav$network_cond_hdlr_trace_buf: [XREF] record
      index: ALIGNED integer,
      buffer: array [0 .. nac$network_ch_trace_buf_size] of record
        clock: integer,
        condition: pmt$condition,
      recend,
    recend;

*copyc osp$set_locked_variable

?? OLDTITLE ??
?? NEWTITLE := '[xdcl, #gate] NAP$CONDITION_HANDLER_TRACE', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$condition_handler_trace
    (    condition: pmt$condition;
         sfsa_p: ^ost$stack_frame_save_area);

    VAR
      ignore_status: ost$status,
      index: integer,
      status: ost$status,
      succeeded: boolean;

    REPEAT
      osp$set_locked_variable (nav$network_cond_hdlr_trace_buf.index, nav$network_cond_hdlr_trace_buf.index,
            (nav$network_cond_hdlr_trace_buf.index + 1) MOD (nac$network_ch_trace_buf_size + 1), index,
            succeeded);
    UNTIL succeeded;

    nav$network_cond_hdlr_trace_buf.buffer [index].clock := #FREE_RUNNING_CLOCK (0);
    nav$network_cond_hdlr_trace_buf.buffer [index].condition := condition;

    CASE nav$cond_handler_trace_level OF
    = 0 =
      RETURN; {----->

    = 1 =
      IF condition.selector IN $pmt$condition_combination [pmc$block_exit_processing,
            ifc$interactive_condition, pmc$user_defined_condition] THEN
        RETURN; {----->
      IFEND;

    = 2 =
      IF (condition.selector = ifc$interactive_condition)
{   } OR ((condition.selector = pmc$user_defined_condition) AND
            ((condition.user_condition_name = ifc$interrupt_timesharing_io) OR
            (condition.user_condition_name = osc$job_recovery_condition_name))) THEN
        RETURN; {----->
      IFEND;

    = 3 =
      ;
    ELSE
      ;
    CASEND;

    osp$set_status_from_condition (nac$status_id, condition, sfsa_p, status, ignore_status);
    nap$namve_system_error (TRUE {=recoverable} , 'Condition Handler called:', ^status);

  PROCEND nap$condition_handler_trace;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] nap$get_file_cycle_count', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$get_file_cycle_count (path: pft$path;
    VAR cycles: 0 .. pfc$maximum_cycle_number;
    VAR status: ost$status);

    VAR
      cycle_array: pft$p_cycle_array,
      directory: pft$p_directory_array,
      group: pft$group,
      info: pft$p_info,
      info_offset: pft$array_index,
      info_record: pft$p_info_record,
      info_segment_pointer: mmt$segment_pointer,
      item_record: pft$p_info_record,
      local_status: ost$status;

    status.normal := TRUE;

    IF (NOT jmv$executing_within_system_job) AND (NOT osp$is_caller_system_privileged()) THEN
      osp$set_status_abnormal('NA',nae$insufficient_privilege,
            'nap$get_file_cycle_count',status);
      RETURN;
    IFEND;

    mmp$create_segment (NIL, mmc$sequence_pointer, 1, info_segment_pointer, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    info := info_segment_pointer.seq_pointer;
    RESET info;

    group.group_type := pfc$member;
    group.member_description.family := osc$null_name;
    group.member_description.account := osc$null_name;
    group.member_description.project := osc$null_name;
    group.member_description.user := osc$null_name;

    cycles := 0;
    pfp$get_item_info (path, group, $pft$catalog_info_selections [], $pft$file_info_selections
          [pfc$file_directory, pfc$file_description, pfc$file_cycles], info, status);
    IF status.normal THEN
      RESET info;
      pfp$find_next_info_record (info, info_record, status);
      IF status.normal THEN
        pfp$find_directory_array (info_record, directory, status);
        IF status.normal AND (directory <> NIL) THEN

          pfp$find_direct_info_record (^info_record^.body, directory^ [LOWERBOUND (directory^)].info_offset,
                item_record, status);
          IF status.normal THEN
            pfp$find_cycle_array (item_record, cycle_array, status);
            IF status.normal THEN
              IF cycle_array = NIL THEN
                cycles := 0;
              ELSE
                cycles := UPPERBOUND (cycle_array^);
              IFEND;
            IFEND;
          IFEND;
        IFEND;
      IFEND;
    ELSEIF status.condition = pfe$unknown_permanent_file THEN
      status.normal := TRUE;
    IFEND;

    mmp$delete_segment (info_segment_pointer, 1, local_status);
    IF status.normal AND (NOT local_status.normal) THEN
      status := local_status;
    IFEND;
  PROCEND nap$get_file_cycle_count;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] nap$display_message', EJECT ??

  PROCEDURE [XDCL, #GATE] nap$display_message (status_message: ost$status);

    VAR
      line_length: ^ost$status_message_line_size,
      line_count: ^ost$status_message_line_count,
      line_index: ost$status_message_line_count,
      log: pmt$ascii_logset,
      message: ost$status_message,
      message_sequence: ^ost$status_message,
      text: ^ost$status_message_line,
      ignore_status: ost$status;

    IF jmv$executing_within_system_job OR osp$is_caller_system_privileged() THEN
      log := $pmt$ascii_logset [pmc$job_log, pmc$system_log];
    ELSE
      log := $pmt$ascii_logset [pmc$job_log];
    IFEND;

    osp$format_message (status_message, osc$current_message_level, osc$max_status_message_line, message,
          ignore_status);

    message_sequence := ^message;
    RESET message_sequence;
    NEXT line_count IN message_sequence;

    FOR line_index := 1 TO line_count^ DO
      NEXT line_length IN message_sequence;
      NEXT text: [line_length^] IN message_sequence;
      pmp$log_ascii (text^, log, pmc$msg_origin_program, ignore_status);
    FOREND;

  PROCEND nap$display_message;
?? OLDTITLE ??
?? NEWTITLE := '[XDCL, #GATE] nap$namve_system_error', EJECT ??
*copy nah$namve_system_error

  PROCEDURE [XDCL, #GATE] nap$namve_system_error
    (    recoverable_error: boolean;
         error_message: string ( * );
         status: ^ost$status);

    VAR
      caller_id: ost$caller_identifier,
      ignore_status: ost$status,
      request_block: mmt$rb_idle_system;


    osp$verify_system_privilege;

    #caller_id (caller_id);
    IF caller_id.ring <= mtv$halt_cpu_ring_number THEN
      osp$system_error (error_message, status);
    IFEND;

    IF nav$debug_mode = nac$halt_on_error THEN
      request_block.reqcode := syc$rc_idle_system;
      request_block.idle_code := syc$ic_fatal_software_error;
      request_block.error_message (1, 8) := 'NAM/VE: ';
      request_block.error_message (9, *) := error_message;
      WHILE TRUE DO
        i#call_monitor (#LOC (request_block), #SIZE (request_block));
      WHILEND;
    ELSE

{ Call OSP$RECOVERABLE_SYSTEM_ERROR whether or not the error is recoverable. This is
{ done to lay down the call chain in the logs.

      osp$recoverable_system_error (error_message, status);

{ If SYSTEM_DEBUG_RING already caused OSP$RECOVERABLE_SYSTEM_ERROR to bring the
{ debugger up on this task do not do it again.

      IF (caller_id.ring > tmv$system_debug_ring) AND (nav$debug_mode = nac$debug_on_error) THEN
        syp$invoke_system_debugger (error_message, 0, ignore_status);
      IFEND;
      IF NOT recoverable_error THEN
        osp$system_error (error_message, status);
      IFEND;
    IFEND;

  PROCEND nap$namve_system_error;


MODEND nam$miscellaneous;
