Google
 

Trailing-Edge - PDP-10 Archives - BB-X117B-SB_1986 - 10,7/nml/nmlevd.bli
There is 1 other file named nmlevd.bli in the archive. Click here to see a list.
! UPD ID= 238, SNARK:<6.1.NML>NMLEVD.BLI.7,  20-Jan-85 16:48:21 by GLINDELL
!  1. Remove debugging code that did implicit SET KNOWN EVENTS for console
!     and monitor.
!  2. Add event 96.0 to the monitor filter table
!
! UPD ID= 204, SNARK:<6.1.NML>NMLEVD.BLI.6,  10-Dec-84 15:24:15 by HALPIN
! Get MONSYM Library file out of default directory, not BLI:
!
! UPD ID= 86, SLICE:<6.1.NML>NMLEVD.BLI.5,  18-Sep-84 15:00:18 by GUNN
! WORK:<GUNN.NML>NMLEVD.BLI.3 21-Aug-84 14:43:32, Edit by GUNN
!
! Remove definition of $NTSLM. It is in now MONSYM.
!
! WORK:<GUNN.NML>NMLEVD.BLI.2 21-Aug-84 12:06:09, Edit by GUNN
!
! Change to accomodate new LIBRARY conventions. MONSYM.L36 and JLNKG.L36
! are now explicity declared here rather than in NMULIB.
!
! UPD ID= 62, SNARK:<6.1.NML>NMLEVD.BLI.4,  26-Jun-84 16:04:56 by GLINDELL
! Module too big: a 'field' should be a '$field'
!
! UPD ID= 37, SNARK:<6.1.NML>NMLEVD.BLI.3,  24-May-84 16:28:33 by GLINDELL
! Check size of response buffer when writing to it on SHOW commands
!
! PH4:<GLINDELL>NMLEVD.BLI.2 29-Feb-84 20:31:39, Edit by GLINDELL
! Ident 3.
!  APPLY_FILTER tested for 0 instead of for $true at return of callback.
!
! PH4:<GLINDELL>NMLEVD.BLI.13 16-Feb-84 13:14:43, Edit by GLINDELL
! Ident 2.
!  Move the database to get the event text to NMARCH.
!  Minor other changes
!
! PH4:<GLINDELL>NMLEVD.BLI.80  1-Feb-84 13:05:59, Edit by GLINDELL
!
!  Continue work on event logger database

%title 'NMLEVD -- NML Event Logger Database handler'
module NMLEVD  (
                ident = 'X04.03'
               ) =
begin

!                    COPYRIGHT (c) 1984 BY
!	      DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS.
!
! THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND  COPIED
! ONLY  IN  ACCORDANCE  WITH  THE  TERMS  OF  SUCH  LICENSE AND WITH THE
! INCLUSION OF THE ABOVE COPYRIGHT NOTICE.  THIS SOFTWARE OR  ANY  OTHER
! COPIES  THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY
! OTHER PERSON.  NO TITLE TO AND OWNERSHIP OF  THE  SOFTWARE  IS  HEREBY
! TRANSFERRED.
!
! THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE  WITHOUT  NOTICE
! AND  SHOULD  NOT  BE  CONSTRUED  AS  A COMMITMENT BY DIGITAL EQUIPMENT
! CORPORATION.
!
! DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR  RELIABILITY  OF  ITS
! SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL.
!

!++
! FACILITY:	DECnet-10/20 V4.0 Network Management Layer (NML)
!
! ABSTRACT:
!
!	This module contains the routines that interface to the EVENT
!	LOGGER volatile database.
!
! ENVIRONMENT: TOPS-10/20 User mode under NML
!
! AUTHOR: Gunnar Lindell, 22-Dec-1983
!
!--

!
! INCLUDE FILES
!

library 'NMLLIB';                       ! All required definitions

%if $TOPS20
    %then
	library 'MONSYM';			! Monitor symbols

	library 'JLNKG';			! JSYS linkage definitions
    %fi
%if $TOPS10
%then literal $NTSLM = -4;
%fi

require 'NMLEXT';                       ! NML external routines

!
! TABLE OF CONTENTS
!

! Global routines (called from other modules) have names that begin with
! NML$EVL_. Local routines are the rest.

forward routine
        NML$EVL_INITIALIZE : novalue,   ! Initialize data base
        NML$EVL_INSERT_PARAMETER,       ! Insert logging parameter
        NICE_DECODE,                    ! Decode NICE messages
        PROCESS_EVENT,                  ! Process event
        INSERT_EVENT,                   ! Insert event
        FIND_EVENT,                     ! Search database
        RECOMPUTE_MONITOR_FILTER :
                          novalue,      ! Recompute the monitor filter
        RECOMPUTE_CLASS_FILTER :
                          novalue,      ! Recompute the filters for a class
        NML$EVL_DELETE_PARAMETER,       ! Delete logging parameter
        DELETE_EVENT,                   ! Delete event
        CLEAN_UP: novalue,              ! Clean up after deleting events
        FIND_NEXT_CLASS,                ! Search for next non-zero class
        NML$EVL_READ_EVENTS,            ! Read logging parameter
        SHOW_SINK_NODE,                 ! Show events for a sink node
        EVENT_ENCODE : novalue,         ! Make NICE response of an event
        NML$EVL_APPLY_FILTER,           ! Apply all relevant filters
        SEARCH_FILTER,                  ! Search for filters
        NML$EVL_SET_VDB_PARAMETER,      ! NML internal SET logging parameter
        NML$EVL_CLR_VDB_PARAMETER,      ! NML internal CLEAR logging parameter
        NML$EVL_GET_VDB_PARAMETER,      ! NML internal READ logging parameter
        NML$EVL_EVENT_TEXT,             ! Get the event text for an event
        SINK_NODE_MATCH,                ! Match sink node (NMU$QUEUE_SCAN)
        CLASS_MATCH,                    ! Match class (NMU$QUEUE_SCAN)
        EVENT_ENTITY_MATCH,             ! Match event entity block ( " ")
        ENTITY_FILTER_MATCH,            ! Match event entity block ( " ")
        GET_MEMORY,                     ! Memory allocator
        RELEASE_MEMORY : novalue        ! Memory deallocator
        ;


!
! External routines
!

external routine
         NMU$NETWORK_LOCAL,             ! Get local node address and name
         NML$CONVERT_ENTITY_ID;         ! Convert entity ID

!
! Local macros
!

! The BYTE8(N) generates a subblock for N 8-bit bytes.

macro
     $byte8(N) = $sub_block((N+3)/4) %;

!
! DECnet parameters and bit fields
!

! Parameter numbers:

literal
       SINK_NODE_PARAMETER = 200,
       EVENT_PARAMETER = 201;

! Bit fields for CONSOLE, FILE and MONITOR sinks.

macro
     CONSOLE_MASK = 0,1,0 %,
     FILE_MASK    = 1,1,0 %,
     MONITOR_MASK = 2,1,0 %,
     SINK_MASK    = 0,3,0 %;

! Bit fields for EVENT CLASS and "EVENT QUALIFIER" in NICE messages

macro
     NICE_EVENT_CLASS_MASK = 0,9,0 %,
     NICE_EVENT_QUALIFIER_MASK = 14,2 %;

!++
!
! Generate event code table. This table contains all events that are
! known (generated) by the host.
!
! The table contains event class and type, event applicability and the
! event text.
!
! The applicability field determines whether the event is associated with
! a particular entity on the local node, with no entity on the local node,
! with all entities on the local node or only with remote nodes.

! Define the fields of an event entry in the table.

$field EVENT_LIST_FIELDS =
      set
      EV_CLASS     = [ $short_integer ],
      EV_TYPE      = [ $short_integer ],
      EV_APPL      = [ $short_integer ],
      EV_TEXT      = [ $integer ]
      tes;

literal
      EVENT_LIST_SIZE = $field_set_size;

! GEN_EVENT_TABLE and GEN1_EVENT_TABLE generate the preset value for
! one event
macro GEN_EVENT_TABLE[NAM] =
         GEN1_EVENT_TABLE(%count, %remove(NAM)) %;

macro GEN1_EVENT_TABLE(INDEX,A,B,C,D) =
         [INDEX, EV_CLASS] = A,
         [INDEX, EV_TYPE] = B,
         [INDEX, EV_APPL] = C,
         [INDEX, EV_TEXT] = ch$ptr(uplit(%asciz D)) %;

! MAKE_EVENT_TABLE generates the event table
!
!  NML$EVENTS (the events) are generated in NMARCH

macro MAKE_EVENT_TABLE [] =
         literal NR_EVENTS = %length;
         own EVENT_TABLE : blockvector[NR_EVENTS, EVENT_LIST_SIZE]
                           field (EVENT_LIST_FIELDS)
                           preset (GEN_EVENT_TABLE(%remaining)) %;

! Now expand the event table
MAKE_EVENT_TABLE($NML$EVENTS);


! The list of event classes that the monitor might generate are listed here.
! RECOMPUTE_MONITOR_FILTER accesses this list to find out what global
! masks it has to care about. Also, there is a parallell data table to
! this table that holds the current global masks. The size of that table
! (MONITOR_FILTER_TABLE) is generated in the macro expansion.

! The $MONITOR_FILTER macro generates counts the arguments and puts that
! into a compile-time constant.

compiletime
           MONITOR_FILTER_COUNT = 0;

macro
     $MONITOR_FILTER [F1] =
              %assign(MONITOR_FILTER_COUNT , MONITOR_FILTER_COUNT + 1)
              F1 %;

! The monitor currently generates event classes 2 through 6. Add to the
! list below if needed.

bind MONITOR_FILTER_ADR = plit($MONITOR_FILTER(2,3,4,5,6,96));

!++
!
! Define FILTER
!
! FILTER is a data structure that will represent one filter mask. A filter
! mask represents the event types within an event class. There are a maximum
! of 32 event types within an event class. If bit 0 in BLISS sense is set,
! that means that event type 0 shall be logged and NOT filtered.
!
!--

macro
     $FILTER = $bits(32) %;

!++
!
! Define EVENT_ENTITY_BLOCK
!
! The EVENT_ENTITY_BLOCK represents the filter associated to a source
! entity. The source entity can be AREA, CIRCUIT, LINE, MODULE or NODE.
! In the block, the entity type is kept as well as the entity ID or name.
! The filter for the entity is also kept, as well as queue link information.
! The event class for the entity is implied by the CLASS_BLOCK that points
! to the EVENT_ENTITY_BLOCK
!
!--

$field
      EVENT_ENTITY_FIELDS =
      set
      EVENT_ENTITY_QUEUE  = [ $sub_block(Q_ENTRY_SIZE) ],
      EVENT_ENTITY_TYPE   = [ $tiny_integer ],
      EVENT_ENTITY_ID     = [ $byte8(2 + max(0,9,17)) ],
      EVENT_ENTITY_FILTER = [ $filter ]
      tes;

literal
       EVENT_ENTITY_SIZE = $field_set_size,
       EVENT_ENTITY_ALLOCATION = $field_set_units;

macro
     EVENT_ENTITY_BLOCK = block [ EVENT_ENTITY_SIZE ]
                                field ( EVENT_ENTITY_FIELDS ) %;

!++
!
! Define CLASS_FILTER
!
! The CLASS_FILTER is a subblock within the CLASS_BLOCK structure.
! It represents the filter information associated with one event class.
! The event class number is implied by its position within the CLASS_
! BLOCK along with the CLASS_LOW and CLASS_HIGH specifiers. The CLASS_
! FILTER points to a list of EVENT_ENTITY_BLOCKS. If there is no entity
! that matches there is also a "catch-all" global filter defined.
!
!--

$field CLASS_FILTER_FIELDS =
       set
       GLOBAL_FILTER   = [ $filter ],
       QH_EVENT_ENTITY = [ $sub_block(Q_HEADER_SIZE) ]
       tes;

literal
       CLASS_FILTER_SIZE = $field_set_size;

macro
     CLASS_FILTER_BLOCK = block [ CLASS_FILTER_SIZE ]
                                  field (CLASS_FILTER_FIELDS) %;

!++
!
! Define CLASS_BLOCK
!
! The CLASS_BLOCK represents the filter information for a sequence of
! 8 event classes. The CLASS_LOW and the CLASS_HIGH gives the boundaries
! of the event classes. The CLASS_LOW is always a multiple of 8. (Note
! that the CLASS_HIGH is superfluous information).
!
! For each class within the sequence a CLASS_FILTER subblock is allocated.
! See above for a description of the CLASS_FILTER.
!
! The CLASS_BLOCK also has queue information to link it to the other
! CLASS_BLOCK's.
!
! Note: It will only be useful to represent event classes that can be
!	generated on the local system. (Remote events are not filtered).
!	The local event classes are:
!		0-6	NML to physical link layer
!		96-127	TOPS-10/TOPS-20 specific events
!	It is assumed that only one of the TOPS-20 specific classes will
!	be needed. Therefore, more than two CLASS_BLOCKs will seldom be
!	used. The first one will contain all the common classes 0-7 so
!	this points to a reasonably efficient representation of data.
!
!++

$field
      CLASS_FIELDS =
      set
      CLASS_QUEUE        = [ $sub_block(Q_ENTRY_SIZE) ],
      CLASS_LOW          = [ $integer ],
      CLASS_HIGH         = [ $integer ],
      CLASS_FILTER_AREA  = [ $sub_block(8 * CLASS_FILTER_SIZE) ]
      tes;

literal
       CLASS_SIZE = $field_set_size,
       CLASS_ALLOCATION = $field_set_units;

macro
     CLASS_BLOCK = block [ CLASS_SIZE ] field ( CLASS_FIELDS ) %;

!++
!
! Define SINK_NODE_BLOCK
!
! The SINK_NODE_BLOCK represents one sink node and the local sinks
! on that sink node. It contains the sink node name for identification.
! The sink node name is represented as 2 bytes with the node number,
! 1 byte length of node name (possibly 0) followed by 6 bytes of node
! name. For easy reference, the flag SINK_NODE_LOCAL is set if this is the
! local node.
!
! The SINK_NODE_BLOCK has a CLASS_BLOCK queue header for each local sink
! on the sink node. If the local sink is not active, the CLASS_BLOCK list
! will not contain any entries.
!
! Also there is information on what transmitter queue that services this
! sink node. This is an index that the event logger module NMXEVT will use.
!
! To string all SINK_NODE_BLOCKs together, there is queue information.
!
! The head of the event data structure is QH_SINK_NODES that point to
! the first SINK_NODE_BLOCK.
!
!--

$field
      SINK_NODE_FIELDS =
      set
      SINK_NODE_QUEUE  = [ $sub_block(Q_ENTRY_SIZE) ],
      SINK_NODE_NAME   = [ $byte8(NODE_ID_BUFFER_LENGTH) ],
      SINK_NODE_LOCAL  = [ $bits(1) ],
      QH_CONSOLE_CLASS = [ $sub_block(Q_HEADER_SIZE) ],
      QH_FILE_CLASS    = [ $sub_block(Q_HEADER_SIZE) ],
      QH_MONITOR_CLASS = [ $sub_block(Q_HEADER_SIZE) ]
      tes;

literal
       SINK_NODE_SIZE = $field_set_size,
       SINK_NODE_ALLOCATION = $field_set_units;

macro
     SINK_NODE_BLOCK = block [ SINK_NODE_SIZE ] field (SINK_NODE_FIELDS) %;

!++
!
! Here follows a brief layout of the structure of the database:
!
! QH_SINK_NODES
!     |
!     |
!     v
!   SINK_NODE_BLOCK
!   |   QH_FILE_CLASS ----> CLASS_BLOCK
!   |   QH_CONSOLE_CLASS    |   CLASS_LOW
!   |                       |   CLASS_HIGH
!   |                       |   8 * CLASS_FILTER_AREA
!   |                       |     QH_EVENT_ENTITY ---------> EVENT_ENTITY_BLOCK
!   |                       |     GLOBAL_FILTER               |   ENTITY_ID
!   |                       |                                 |   FILTER
!   |                       |                                 |
!   |                       |                                 |
!   |                       |                                EVENT_ENTITY_BLOCK
!   |                       |
!   |                       CLASS_BLOCK
!   |
!   |
!   SINK_NODE_BLOCK
!
!--

!++
!
! Define NICE_BLOCK
!
! The routines to insert and delete parameters (NML$EVL_INSERT_PARAMETER and
! NML$EVL_DELETE_PARAMETER) need to scan parts of a NICE message to get the
! SINK NODE and EVENT parameters and their values.
!
! For simplicity there is one scanning routine that does all the work.
! The result is put into a NICE_BLOCK for further use.
!
! The NICE_BLOCK contains the sink node name in canonical format,
! the sink type {CONSOLE, FILE and MONITOR}, a flag "KNOWN EVENTS"
! signifying all local events, the event class and filter, the event
! entity type that applies (can be NO_ENTITY) and the entity ID in
! canonical format.
!
! Only one instance of a NICE_BLOCK will exist.
!
!--

$field NICE_BLOCK_FIELDS =
       set
       NB_SINK_NODE_ID       = [ $byte8(NODE_ID_BUFFER_LENGTH) ],
       NB_SINK_TYPE          = [ $tiny_integer ],
       NB_KNOWN_EVENTS       = [ $bits(1) ],
       NB_EVENT_CLASS        = [ $integer ],
       NB_EVENT_FILTER       = [ $filter ],
       NB_EVENT_ENTITY_TYPE  = [ $tiny_integer ],
       NB_EVENT_ENTITY_ID    = [ $byte8(2 + max(0,9,17)) ]
       tes;

literal
       NICE_BLOCK_SIZE = $field_set_size;

macro
     NICE_BLOCK = block [ NICE_BLOCK_SIZE] field ( NICE_BLOCK_FIELDS ) %;


!++
!
! Define FILTER_BLOCK
!
! The routine that searches the filter data base (NML$EVL_APPLY_FILTER) and
! the subroutines it calls, need a way to communicate what they are
! searching for.
!
! The FILTER BLOCK contains what sink types the event should be logged at,
! the event class and type, the entity type (possibly NO_ENTITY_) and the
! entity ID. There is also a bit set if this is event 0.0 that has to be
! special cased.
!
! There will be one instance of a FILTER_BLOCK.
!
!--

$field FILTER_BLOCK_FIELDS =
       set
       FB_SINK_FLAGS   = [ $bits(3) ],
          $overlay(FB_SINK_FLAGS)
       FB_SINK_CONSOLE = [ $bits(1) ],
       FB_SINK_FILE    = [ $bits(1) ],
       FB_SINK_MONITOR = [ $bits(1) ],
       FB_EV_0_0       = [ $bits(1) ],
       FB_EVENT_CLASS  = [ $short_integer ],
       FB_EVENT_FILTER = [ $filter ],
       FB_ENTITY_TYPE  = [ $tiny_integer ],
       FB_ENTITY_ID    = [ $byte8(2 + max(0,9,17))]
       tes;

literal
       FILTER_BLOCK_SIZE = $field_set_size;

macro
     FILTER_BLOCK = block [ FILTER_BLOCK_SIZE ] field ( FILTER_BLOCK_FIELDS) %;


!++
!
! Define SHOW_BLOCK
!
! The routines that reads through the database to return all events
! uses a SHOW_BLOCK for communication. The principle is the same as
! for the NICE_BLOCK and the FILTER_BLOCK.
!
! The top level READ/SHOW routine NML$EVL_READ_EVENTS will set the
! values in the SHOW_BLOCK, and subroutines will read parameters
! off the SHOW_BLOCK
!
! Only one instance of a SHOW_BLOCK will exist.
!
!--

$field SHOW_BLOCK_FIELDS =
       set
       SB_RETPTR       = [ $address ],
       SB_SINK_SENT    = [ $bits(1) ],
       SB_SINK_TYPE    = [ $tiny_integer ],
       SB_SINK_NODE_ID = [ $byte8(NODE_ID_BUFFER_LENGTH) ]
       tes;

literal
       SHOW_BLOCK_SIZE = $field_set_size;

macro
     SHOW_BLOCK = block [ SHOW_BLOCK_SIZE ] field ( SHOW_BLOCK_FIELDS ) %;

!++
!
! Data declarations
!
!--

! Define sink node queue header. This is the head of the data base, and leads
! to everything else.
own
   QH_SINK_NODES : Q_HEADER;

! Define nice block. This is the only instance of a nice block and is used in
! several routines.
own
   NB : NICE_BLOCK;

! Define filter block. This is the only instance of a filter block and it is
! used in NML$EVL_APPLY_FILTER and subordinates.
own
   FB : FILTER_BLOCK;

! Define show block. This is the only instance of a show block and it is
! used in NML$EVL_READ_EVENTS and subordinates
own
   SB: SHOW_BLOCK;

! Define global pointers. These are used by all routines.
own
   SINK_NODE_PTR    : ref SINK_NODE_BLOCK,
   QH_CLASS         : ref Q_HEADER,
   CLASS_PTR        : ref CLASS_BLOCK,
   CLASS_FILTER_PTR : ref CLASS_FILTER_BLOCK,
   EVENT_ENTITY_PTR : ref EVENT_ENTITY_BLOCK;

! Define MONITOR_FILTER_TABLE. This table is maintained by RECOMPUTE_MONITOR_
! FILTER and keeps the current global masks. The size of the table is
! determined by the compiletime constant MONITOR_FILTER_COUNT.
own
   MONITOR_FILTER_TABLE : vector[MONITOR_FILTER_COUNT];

%global_routine('NML$EVL_INITIALIZE') : novalue =

! DDT name: ED%INI

!++
!
! Functional description:
!
!	Resets sink node queue header.
!	Performs equivalent to 'SET LOGGING FILE KNOWN EVENTS'
!
!--

!++
!
! Design notes:
!
!	NML$EVL_INITIALIZE initializes the event logger volatile database.
!	It is called by NML$VDB_INITIALIZE in NMLVDB.
!
!	1. The sink node queue header is reset.
!	2. The equivalent of 'SET LOGGING FILE SINK EXECUTOR KNOWN EVENTS'
!	   is performed.
!
!	(2) is accomplished by writing appropriate data into a NICE_BLOCK
!	and calling PROCESS_EVENT(INSERT_EVENT)
!
!--

   begin

! Reset the sink node queue header
   NMU$QUEUE_RESET(QH_SINK_NODES);

! Now perform the equivalent of 
!
!  NCP> SET LOGGING FILE KNOWN EVENTS SINK EXECUTOR
!
! Setup the NB block and call PROCESS_EVENT

   if NML$CONVERT_ENTITY_ID( ENTITY_NODE, %ref(0),
                             ch$ptr(NB[NB_SINK_NODE_ID],,8)) neq $true
   then begin
        TASK_INFO(
            'INTERNAL ERROR: Could not initialize event database'
        );
        return;
        end;
   NB[NB_SINK_TYPE] = FILE_ ;
   NB[NB_KNOWN_EVENTS] = $true;
   NB[NB_EVENT_ENTITY_TYPE] = NO_ENTITY_ ;

   if PROCESS_EVENT(INSERT_EVENT) neq NICE$_SUC
   then begin
        TASK_INFO(
            'INTERNAL ERROR IN NMLT20: Could not initialize event database'
        );
        return;
        end;

   return;

   end;                                 ! End of NML$EVL_INITIALIZE

%global_routine('NML$EVL_INSERT_PARAMETER', ENTITY_TYPE, QUALIFIER,
                PARM_LEN, PARM_PTR) =

! DDT name: ED%INS

!++
!
! FUNCTIONAL DESCRIPTION
!
!	Insert a parameter in the logging database
!
! FORMAL PARAMETERS
!
!	ENTITY_TYPE	Character pointer to entity type
!	QUALIFIER	Character sequence pointer to the qualifier parameter
!	PARM_LEN	The length of the parameter data
!	PARM_PTR	Character sequence pointer to the parameter data

!
! ROUTINE VALUE
!
!	NICE return code
!
! SIDE EFFECTS
!
!	NONE
!
!--

!++
!
! Design notes:
!
!	NML$EVL_INSERT_PARAMETER inserts an event parameter into the
!	event logger volatile database. It is called by VDB_CHANGE in
!	NMLVDB.
!
!	1. NICE_DECODE is called to decode the NICE message, extract
!	   the data and write the data to a NICE_BLOCK. All routines
!	   noted below will use the NICE_BLOCK.
!	2. PROCESS_EVENT will then be called with INSERT_EVENT as
!	   coroutine.
!	3. PROCESS_EVENT is a "jacket" routine that resolves the
!	   'KNOWN SINKS' case. It calls a supplied coroutine to process
!	   each relevant sink (console, file and monitor).
!	4. INSERT_EVENT will call FIND_EVENT to locate the relevant data
!	   block. FIND_EVENT can optionally build the data structure on
!	   its way through the data structure, and this option is used
!	   by INSERT_EVENT.
!	5. FIND_EVENT returns with pointers set up to point to the data
!	   blocks in question, existing before or newly created. 
!	6. INSERT_EVENT stores the event filters into the database
!	7. RECOMPUTE_MONITOR_FILTER is called to recompute the global
!	   filter mask.
!
!--

   begin

! Call NICE_DECODE to decode the incoming NICE message (or rather the
! parameter part of the message) into a NICE_BLOCK (NB).
   if ( NICE_DECODE( .ENTITY_TYPE, .QUALIFIER, .PARM_LEN, .PARM_PTR)
        eql $false ) then return NICE$_IMF;   ! Illegal message format

! Call PROCESS_EVENT to do the job
   return PROCESS_EVENT(INSERT_EVENT);

   end;                                 ! End of NML$EVL_INSERT_PARAMETER

%routine('NICE_DECODE' , ENTITY_TYPE, QUALIFIER,
                  PARM_LEN, PARM_PTR) =

!++
!
! Functional description:
!
!	Decompose NICE message to NICE_BLOCK
!
! Formal parameters:
!
!	ENTITY_TYPE     Pointer to entity type
!	QUALIFIER	Character sequence pointer to the qualifier parameter
!	PARM_LEN	The length of the parameter data
!	PARM_PTR	Character sequence pointer to the parameter data
!
! Returns:	$false	syntax error
!		$true	all well
!
!--

!++
!
! For reference, some NCP commands and their NICE representation is listed
! below:
!	(SET LOGGING MONITOR prefix and corresponding NICE prefix is
!	 excluded. Also, SINK NODE parameter is 310 octal, and EVENT
!	 parameter is 311 octal)
!
! EVENT 4.1			311 000 377 004 000 001 002
! EVENT 4.1-5			311 000 377 004 000 001 016
! EVENT 4.*			311 000 377 004 200
! KNOWN EVENTS                  311 000 377 000 300
!
! EVENT 4.1 CIRCUIT DTE-0-1	311 000 003 007 "D" "T" "E" "-" "0" "-" "1"
!				004 000 001 002
!
!           NODE ETHER::	311 000 000 005 "E" "T" "H" "E" "R"
!				004 000 001 002
!
!           NODE 124		311 000 000 000 174 000 004 000 001 002
!
! EVENT 4.1 SINK NODE ETHER::	311 000 377 004 000 001 002 310 000 005
!				"E" "T" "H" "E" "R"
!
!           SINK NODE 124	311 000 377 004 000 001 002 310 000 000
!				174 000
!--

   begin

! Copy qualifying sink node to NB block, and default local node if necessary
   if .QUALIFIER neq 0
   then begin                           ! There is a qualifier around
        if GETW(QUALIFIER) neq SINK_NODE_PARAMETER
        then return $false;
        end;
   if NML$CONVERT_ENTITY_ID( ENTITY_NODE, QUALIFIER,
                             ch$ptr(NB[NB_SINK_NODE_ID],,8)) neq $true
   then return $false;

! Get logging sink type
   NB[NB_SINK_TYPE] = GETB(ENTITY_TYPE);

! Verify that it the event parameter
   if GETW(PARM_PTR) neq EVENT_PARAMETER then return $false;

! Now get the EVENT_ENTITY_TYPE (signed byte) and EVENT_ENTITY_ID
   begin
   local TMP : $SIGNED_BYTE_VALUE;
   TMP = GETB(PARM_PTR);
   NB[NB_EVENT_ENTITY_TYPE] = .TMP[VALUE];
   end;
   if NML$CONVERT_ENTITY_ID( .NB[NB_EVENT_ENTITY_TYPE], PARM_PTR,
                              ch$ptr(NB[NB_EVENT_ENTITY_ID],,8)) neq $true
   then return $false;

! Now retrieve the event class and type
!
! The format is:
!     1st word:   Bits 14-15   0 = single class
!                              2 = all events for class
!                              3 = KNOWN EVENTS
!                      0-8     Event class if bits 14-15 are 0 or 2
!
! If bits 14-15 are 0 a filter is specified in the following bytes:
! Byte 1 has the count of bytes to follow; the bytes to follow have
! bit x set if filter x is filtered.
!  I.e. sequence 001 002 means type 1 (001 001 would have meant type 0)
!  and 002 000 001 means type 8 (Good luck.....)
! 
   begin
   local TMP;
   NB[NB_KNOWN_EVENTS] = $false;        ! Initialize to false
   TMP = GETW(PARM_PTR);                ! Get event class word
   selectone .TMP<NICE_EVENT_QUALIFIER_MASK> of
      set

      [0] :  ! Single class
             begin
             local COUNT, I, TYPE_VALUE;
             
             NB[NB_EVENT_CLASS] = .TMP<NICE_EVENT_CLASS_MASK>;
             COUNT = GETB(PARM_PTR);         ! Get the count byte
             TYPE_VALUE = 0;

             incr I from 0 to .COUNT-1 do
                  TYPE_VALUE = .TYPE_VALUE or (GETB(PARM_PTR) ^ (8*.I));
             NB[NB_EVENT_FILTER] = .TYPE_VALUE;
             end;

      [1] :  return $false;             ! Value 1 not allowed

      [2] :  ! All types for class
             begin
             NB[NB_EVENT_CLASS] = .TMP<NICE_EVENT_CLASS_MASK>;
             NB[NB_EVENT_FILTER] = -1;
             end;

      [3] :  begin                      ! All known events
             NB[NB_KNOWN_EVENTS] = $true;
             NB[NB_EVENT_CLASS] = 0;    ! Better clear
             NB[NB_EVENT_FILTER] = 0;
             end;

      [otherwise] : return $false;      ! Cannot happen....

      tes;
      end;

   return $true;
   end;

%routine('PROCESS_EVENT' , ROUTINE_TO_CALL) =

!++
!
! Functional description:
!
!	This routine resolves the 'KNOWN EVENTS' case. It is called by
!	NML$EVL_INSERT_PARAMETER, NML$EVL_VDB_INITIALIZE and
!       NML$EVL_DELETE_PARAMETER.
!
!	It dissolves the 'KNOWN EVENTS' into the single event classes and
!	calls the supplied routine to process the event.
!
! Formal parameters:
!
!	ROUTINE_TO_CALL		The routine that will process a single event,
!				typically INSERT_EVENT or DELETE_EVENT
!
! Implicit inputs:
!
!	NB, the NICE BLOCK
!
! Returns:
!
!	NICE message code, NICE$_SUC if all went well
!
!--

   begin

   bind routine
        PROCESSING_ROUTINE = .ROUTINE_TO_CALL;

! If not 'KNOWN EVENTS' then its a single event.
   if .NB[NB_KNOWN_EVENTS] eql $false
   then begin                           ! Single event
        if PROCESSING_ROUTINE() eql $false
        then return NICE$_MPE
        else return NICE$_SUC;
        end
   else begin

        ! KNOWN EVENTS: step through EVENT_TABLE and pick up all events
        ! that answer to the given entity

        local I,                        ! Index
              LAST_CLASS,               ! Last event class seen
              APPL;                     ! Applicability of event

        LAST_CLASS = -1;                ! Initialize to no class seen

        ! Loop over all events
        incr I from 0 to NR_EVENTS - 1
             do begin
                ! First check if this event applies
                APPL = .EVENT_TABLE[.I, EV_APPL];
                if (.APPL eql ANY_ENTITY)
                  or (.APPL eql .NB[NB_EVENT_ENTITY_TYPE])
                  or ((.APPL neq NO_LOCAL)
                        and (.NB[NB_EVENT_ENTITY_TYPE] eql NO_ENTITY_))
                then begin              ! This event applies
                     if .EVENT_TABLE[.I, EV_CLASS] neq .LAST_CLASS
                     then begin         ! Change of class
                          if .LAST_CLASS neq -1
                          then begin    ! Not first class
                               if PROCESSING_ROUTINE() eql $false
                               then return NICE$_MPE;
                               end;
                          ! Come here on all changes of class
                          LAST_CLASS = .EVENT_TABLE[.I, EV_CLASS];
                          NB[NB_EVENT_CLASS] = .LAST_CLASS;
                          NB[NB_EVENT_FILTER] = 1 ^ .EVENT_TABLE[.I, EV_TYPE];
                          end
                     else begin         ! No change of class
                          NB[NB_EVENT_FILTER] =
                             .NB[NB_EVENT_FILTER]
                                or 1 ^ .EVENT_TABLE[.I, EV_TYPE];
                          end;
                     end;

                end;

        ! Falling out here there might be a class to set
        if .LAST_CLASS neq -1
        then if PROCESSING_ROUTINE() eql $false
             then return NICE$_MPE;

        end;

   return NICE$_SUC;

   end;                                 ! End of PROCESS_EVENT

%routine('INSERT_EVENT') =

!++
!
! Functional description:
!
!	This routine inserts a single event. It reads all data it needs
!	from the NB (NICE_BLOCK) and inserts the data into the database
!	appropriately.
!
!       INSERT_EVENT will also call the routine that recomputes the
!       monitor filter.
!
! Formal parameters:
!
!	None
!
! Implicit inputs:
!
!	NB, the NICE_BLOCK filled in
!
! Returns:
!
!	$false	Something went wrong
!	$true	All well
!
!--

   begin

   ! Call FIND_EVENT to do the work. Set the create flag to make it build
   ! the data structures.

   if FIND_EVENT( $true ) eql -1 then return $false;

   ! Now insert the filter: to GLOBAL_FILTER if NO_ENTITY_ , else to
   ! event entity filter

   if .NB[NB_EVENT_ENTITY_TYPE] eql NO_ENTITY_
   then
      CLASS_FILTER_PTR[GLOBAL_FILTER] =
           .CLASS_FILTER_PTR[GLOBAL_FILTER] or .NB[NB_EVENT_FILTER]
   else
      EVENT_ENTITY_PTR[EVENT_ENTITY_FILTER] =
           .EVENT_ENTITY_PTR[EVENT_ENTITY_FILTER] or
           .NB[NB_EVENT_FILTER]
   ;

   ! Need to recompute monitor filter, not delete operation
   RECOMPUTE_MONITOR_FILTER( $false );

   return $true;

   end;                                 ! End of INSERT_EVENT

%routine('FIND_EVENT' , CREATE_FLAG ) =

!++
!
! Functional description:
!
!	This routine is the "workhorse" of the event data base routines.
!	It will search for a specific entry, matching all criterias like
!	sink node name, sink type, class number and source entity ID.
!
!	Along its way it may create the data structure, and insert data
!       from the NB (NICE_BLOCK). However, it will not store any filters
!       into the data structures, it will merely build all structures that
!       are needed to get to the point where the filters are to be stored.
!       The CREATE flag is used by the INSERT_PARAMETER routine. The reason
!       for the filters not being stored are that the higher level INSERT_
!       PARAMETER will resolve the KNOWN_EVENTS case.
!
! Formal parameters:
!
!	CREATE_FLAG	If this parameter is = $TRUE then create 
!			data structures if needed.
!
! Implicit input:
!
!	The routine assumes that NB (the NICE_BLOCK) has been setup for
!	the search.
!
! Returns:
!
!       -1      NMLT20 error.
!
!	0	The searched entry was not in the database. (If CREATE
!		was set, it has now been created)
!
!	1	The searched entry was in the database.
!
! Implicit outputs:
!
!	The following pointers have been set to point to the matching
!	blocks:
!
!		SINK_NODE_PTR
!		CLASS_PTR
!		CLASS_FILTER_PTR
!		EVENT_ENTITY_PTR
!
!	Note: if NO ENTITY was input, EVENT_ENTITY_PTR will be zero.
!
!--

   begin

   local RETURN_VALUE;                  ! The value to return

   SINK_NODE_PTR = 0;                   ! Clear all pointers (just in case)
   CLASS_PTR = 0;
   CLASS_FILTER_PTR = 0;
   EVENT_ENTITY_PTR = 0;

   QH_CLASS = 0;                        ! Clear also pointer
   RETURN_VALUE = 1;                    ! Assume data structure is there

! Search through the sink node list to see it this sink node exists
! before.
   SINK_NODE_PTR = NMU$QUEUE_SCAN(QH_SINK_NODES,
                                  ch$ptr(NB[NB_SINK_NODE_ID],,8),
                                  SINK_NODE_MATCH);

! If the sink node block didnt exist, check if it should be created.
   if .SINK_NODE_PTR eql 0
   then begin
        if .CREATE_FLAG eql $false
        then return 0                   ! Just return...
        else begin
             RETURN_VALUE = 0;          ! We had to create, it wasnt there
             SINK_NODE_PTR = GET_MEMORY(SINK_NODE_ALLOCATION);
             ch$move(NODE_ID_BUFFER_LENGTH, ch$ptr(NB[NB_SINK_NODE_ID],,8),
                     ch$ptr(SINK_NODE_PTR[SINK_NODE_NAME],,8));
             SINK_NODE_PTR[SINK_NODE_LOCAL] =
                  ch$eql(2+1+6, ch$ptr(NB[NB_SINK_NODE_ID],,8),
                         2+1+6, NMU$NETWORK_LOCAL(),
                         0);
             NMU$QUEUE_RESET(SINK_NODE_PTR[QH_CONSOLE_CLASS]);
             NMU$QUEUE_RESET(SINK_NODE_PTR[QH_FILE_CLASS]);
             NMU$QUEUE_RESET(SINK_NODE_PTR[QH_MONITOR_CLASS]);

             NMU$QUEUE_INSERT(QH_SINK_NODES,.SINK_NODE_PTR);
             end;
        end;

! Come here with a pointer to the sink node block in SINK_NODE_PTR.
! Proceed to pick up the correct class queue header.

   case .NB[NB_SINK_TYPE] from LOGGING_LO to LOGGING_HI of
        set
        [CONSOLE_] : QH_CLASS = SINK_NODE_PTR[QH_CONSOLE_CLASS];
        [FILE_]    : QH_CLASS = SINK_NODE_PTR[QH_FILE_CLASS];
        [MONITOR_] : QH_CLASS = SINK_NODE_PTR[QH_MONITOR_CLASS];
        [outrange] : return -1;         ! In case....
        tes;

! Now we have a queue header pointing to a list of class blocks.
! Search through the list to see if this class block exists

   CLASS_PTR = NMU$QUEUE_SCAN(.QH_CLASS, .NB[NB_EVENT_CLASS], CLASS_MATCH);

! If there was not a matching class block, check if it should be created.
! Remember, each class block holds 8 class filters, CLASS_LOW being a
! multiple of 8.

   if .CLASS_PTR eql 0
   then begin
        if .CREATE_FLAG eql $false
        then return 0
        else begin
             RETURN_VALUE = 0;          ! We had to create..
             CLASS_PTR = GET_MEMORY(CLASS_ALLOCATION);

             CLASS_PTR[CLASS_LOW] = (.NB[NB_EVENT_CLASS]/8) * 8; ! Lower limit
             CLASS_PTR[CLASS_HIGH] = .CLASS_PTR[CLASS_LOW] + 7; ! Upper limit

             begin                           ! Reset all entity queue headers,
                                             ! store 0 into all global filters
             local I;                        ! Just an index

             CLASS_FILTER_PTR = CLASS_PTR[CLASS_FILTER_AREA];
             incr I from 0 to 7 do
                  begin
                  NMU$QUEUE_RESET(CLASS_FILTER_PTR[QH_EVENT_ENTITY]);
                  CLASS_FILTER_PTR[GLOBAL_FILTER] = 0;
                  CLASS_FILTER_PTR = .CLASS_FILTER_PTR + CLASS_FILTER_SIZE;
                  end;
             end;          
        
             NMU$QUEUE_INSERT(.QH_CLASS,.CLASS_PTR);
             end;
        end;

! At this point, CLASS_PTR points to the correct class block.
! First, make CLASS_FILTER_PTR point to the correct CLASS_FILTER subblock.
! Second, if the entity type was NO ENTITY then no more need to be done

   CLASS_FILTER_PTR = CLASS_PTR[CLASS_FILTER_AREA] +
                      (.NB[NB_EVENT_CLASS] - .CLASS_PTR[CLASS_LOW]) *
                      CLASS_FILTER_SIZE;

   if .NB[NB_EVENT_ENTITY_TYPE] eql NO_ENTITY_
   then return .RETURN_VALUE            ! No more to do, return value
   else begin

        ! At this point, there is an entity specifier and we must search
        ! the entity lists. This is done in the usual way with NMU$QUEUE_SCAN.
        ! If there is no match, check if an EVENT_ENTITY block should be
        ! created.

        EVENT_ENTITY_PTR =
              NMU$QUEUE_SCAN(CLASS_FILTER_PTR[QH_EVENT_ENTITY],
                             NB, EVENT_ENTITY_MATCH);

        if .EVENT_ENTITY_PTR eql 0
        then begin
             if .CREATE_FLAG eql $false
             then return 0
             else begin
                RETURN_VALUE = 0;
                EVENT_ENTITY_PTR = GET_MEMORY(EVENT_ENTITY_ALLOCATION);

                EVENT_ENTITY_PTR[EVENT_ENTITY_TYPE] =
                      .NB[NB_EVENT_ENTITY_TYPE];
                ch$move(2 + max(0,9,17), ch$ptr(NB[NB_EVENT_ENTITY_ID],,8),
                        ch$ptr(EVENT_ENTITY_PTR[EVENT_ENTITY_ID],,8));
                EVENT_ENTITY_PTR[EVENT_ENTITY_FILTER] = 0;

                NMU$QUEUE_INSERT(CLASS_FILTER_PTR[QH_EVENT_ENTITY],
                                 .EVENT_ENTITY_PTR);
                end;
             end;
        end;

   return .RETURN_VALUE;                ! Return 0 or 1

   end;                                 ! End of FIND_EVENT

%routine ('RECOMPUTE_MONITOR_FILTER' , DELETE_FLAG) : novalue =

!++
!
! Functional description:
!
!	This routine will recompute the monitor filter
!
! Formal parameters:
!
!	DELETE_FLAG	If this parameter is $TRUE then a CLEAR on the
!			database is the reason for the call, otherwise it
!			is an insert.
!
! Implicit outputs:
!
!	May change the global logging masks in the monitor.
!
!--

   begin

   local INDEX,                         ! Index into MONITOR_FILTER_TABLE
         I,                             ! Just a loop index
         NEW_MASK;                      ! The new monitor mask

   ! First check if this event class is used in the monitor, and if so,
   !  find its index.
   INDEX = -1;                          ! Initialize
   incr I from 0 to (.(MONITOR_FILTER_ADR - 1)) - 1 do
        if .NB[NB_EVENT_CLASS] eql (.(MONITOR_FILTER_ADR + .I))
        then begin
             INDEX = .I;
             exitloop;
             end;
   if .INDEX eql -1 then return;        ! No more worries, not monitor mask

   ! Now check whether the routine is called as a result of an INSERT or
   ! DELETE.
   if not .DELETE_FLAG
   then                                 ! Means INSERT, easy...
        ! Just take the old filter and OR with the new one. If the new and
        ! the old are different, set it in the monitor.
        NEW_MASK = .MONITOR_FILTER_TABLE[.INDEX]
                    or .NB[NB_EVENT_FILTER]
   else begin                           ! DELETE/CLEAR, more work...

        ! For all sinks on each sink node, locate all filters that belong
        ! to the event class we are recomputing for...

        NEW_MASK = 0;                   ! Initial state

        ! Loop over sink nodes
        SINK_NODE_PTR = 0;
        while (SINK_NODE_PTR =
               NMU$QUEUE_NEXT(QH_SINK_NODES,.SINK_NODE_PTR)) neq 0 do
               begin

               ! For each sink, call RECOMPUTE_CLASS_FILTER. That routine
               ! will find all filters with the given event class for a
               ! specific sink

               QH_CLASS = SINK_NODE_PTR[QH_CONSOLE_CLASS];
               RECOMPUTE_CLASS_FILTER(.NB[NB_EVENT_CLASS] , NEW_MASK);

               QH_CLASS = SINK_NODE_PTR[QH_FILE_CLASS];
               RECOMPUTE_CLASS_FILTER(.NB[NB_EVENT_CLASS] , NEW_MASK);

               QH_CLASS = SINK_NODE_PTR[QH_MONITOR_CLASS];
               RECOMPUTE_CLASS_FILTER(.NB[NB_EVENT_CLASS] , NEW_MASK);

               end;
        end;

        if .NEW_MASK neq .MONITOR_FILTER_TABLE[.INDEX]
        then begin                      ! Set and store new filter
             $$NML_INTERFACE_EXPAND(
                   $NTSLM,              ! Function code 'SET LOGGING MASKS'
                   ENTITY_LOGGING,      ! Entity type
                   0,                   ! No entity ID
                   .NEW_MASK,           ! New mask goes to qualifier field
                   .NB[NB_EVENT_CLASS]  ! Selection criteria is event class
                                    );
             MONITOR_FILTER_TABLE[.INDEX] = .NEW_MASK;
             end;

   return;

   end;                                 ! End of RECOMPUTE_MONITOR_FILTER

%routine ('RECOMPUTE_CLASS_FILTER' , EVENT_CLASS , MASK ) : novalue =

!++
!
! Functional description:
!
! This routine will locate all filters for a given event class and OR them
! into the word pointed to by MASK. This routine is called after a CLEAR/
! DELETE operation when monitor filters are recomputed.
!
! Formal parameters:
!
!     EVENT_CLASS      The event class that is being recomputed
!     MASK             Address of the word whereto the filters are ORed
!
! Implicit outputs:
!
!     Changes word pointed to by MASK
!
!--

   begin

   ! Find the class block that answers to this event class
   CLASS_PTR = NMU$QUEUE_SCAN(.QH_CLASS, .EVENT_CLASS, CLASS_MATCH);
   if .CLASS_PTR eql 0 then return;     ! No work needed

   ! Find the class filter
   CLASS_FILTER_PTR =
         CLASS_PTR[CLASS_FILTER_AREA] +
         (.EVENT_CLASS - .CLASS_PTR[CLASS_LOW]) * CLASS_FILTER_SIZE;

   ! Apply global filter before looking for any entity filters
   .MASK = ..MASK or .CLASS_FILTER_PTR[GLOBAL_FILTER];

   ! Now step over all entity blocks that belong to this class
   EVENT_ENTITY_PTR = 0;

   while (EVENT_ENTITY_PTR =
          NMU$QUEUE_NEXT(CLASS_FILTER_PTR[QH_EVENT_ENTITY],
              .EVENT_ENTITY_PTR)) neq 0 do
                     ! Now OR in the event entity filter
                     .MASK = ..MASK or .EVENT_ENTITY_PTR[EVENT_ENTITY_FILTER];

   return;

   end;

%global_routine('NML$EVL_DELETE_PARAMETER', ENTITY_TYPE, QUALIFIER,
                                              PARM_LEN, PARM_PTR) =

! DDT name: ED%DEL

!++
!
! FUNCTIONAL DESCRIPTION
!
!	Deletes a parameter in the logging database
!
! FORMAL PARAMETERS
!
!	ENTITY_TYPE	The entity type number
!	QUALIFIER	Character sequence pointer to the qualifier parameter
!	PARM_LEN	The length of the parameter data
!	PARM_PTR	Character sequence pointer to the parameter data
!
! ROUTINE VALUE
!
!	NICE return code
!
! SIDE EFFECTS
!
!	NONE
!
!--

!++
!
! Design notes:
!
!	NML$EVL_DELETE_PARAMETER deletes an event parameter from the event
!	logger volatile database. It is called by VDB_CHANGE in NMLVDB.
!
!	1. NICE_DECODE is called to decode the NICE message, extract the
!	   data and write the data to the NICE_BLOCK. [Compare with
!	   NML$EVL_INSERT_PARAMETER]
!	2. PROCESS_EVENT is called with DELETE_EVENT as coroutine.
!	3. PROCESS_EVENT resolves 'KNOWN SINKS' and calls the coroutines
!	   for each appropriate sink.
!	4. DELETE_EVENT calls FIND_EVENT to locate the relevant data blocks.
!	5. The event parameter is deleted
!	6. CLEAN_UP is called after a DELETE operation in the database.
!	   It starts at the data blocks containing the deleted event
!	   parameter and works it way up. If a data block is unused and
!	   does not point to anything, the block is deallocated.
!	7. RECOMPUTE_MONITOR_FILTER is called to recompute the global filter
!	   mask.
!
!--

   begin

   local TEMP;                          ! Temporary variable

   if ( NICE_DECODE( .ENTITY_TYPE, .QUALIFIER, .PARM_LEN, .PARM_PTR)
        eql $false ) then return NICE$_IMF;   ! Illegal message format

   ! Call PROCESS_EVENT to do (some of) the work.
   if (TEMP = PROCESS_EVENT(DELETE_EVENT)) neq NICE$_SUC then return .TEMP;
   
   ! More work (possibly) if this was 'KNOWN EVENTS'

   if .NB[NB_KNOWN_EVENTS] eql $true
   then begin
        NB[NB_EVENT_FILTER] = -1;
        while (TEMP = FIND_NEXT_CLASS()) neq -1 do
               begin
               NB[NB_EVENT_CLASS] = .TEMP;
               if (TEMP = DELETE_EVENT()) neq NICE$_SUC then return .TEMP;
               end;
        end;

   return NICE$_SUC;
   end;                                 ! End of NML$EVL_DELETE_PARAMETER

%routine('DELETE_EVENT') =

!++
!
! Functional description:
!
!	Deletes a single event from the data structure. If as a consequence
!	data structures will become unused, the space will be reclaimed 
!	through calling the CLEAN_UP routine.
!
!       DELETE_EVENT will also call the routine that recomputes the monitor
!       filter.
!
! Formal parameters:
!
!	None.
!
! Implicit inputs:
!
!	NB, the NICE block
!
! Returns:
!
!	$false	Some error occurred
!	$true	All well
!
! Implicit output:
!
!       The monitor filter might be changed
!	Data structure might be pruned through calling CLEAN_UP
!
!--

   begin

   ! Call FIND_EVENT to locate the event. 
   case FIND_EVENT( $false ) from -1 to +1 of
        set
        [-1] : return $false;           ! Should not happen...
        [0]  : return $true;            ! Wasnt there, signal?? **TBS
        [+1] : $true;                   ! Just continue
        [outrange] : return $false;     ! Should not happen...
        tes;

   ! An entry was found, delete the event type(s) specified
   if .NB[NB_EVENT_ENTITY_TYPE] eql NO_ENTITY_     ! No entity specified
   then
      CLASS_FILTER_PTR[GLOBAL_FILTER] =
            .CLASS_FILTER_PTR[GLOBAL_FILTER] and (not .NB[NB_EVENT_FILTER])
   else
      EVENT_ENTITY_PTR[EVENT_ENTITY_FILTER] =
            .EVENT_ENTITY_PTR[EVENT_ENTITY_FILTER] and
            (not .NB[NB_EVENT_FILTER])
   ;

   ! Now delete unused data structures
   CLEAN_UP();

   ! The monitor filter needs to be recalculated, and it is delete operation
   RECOMPUTE_MONITOR_FILTER( $true );

   return $true;

   end;                                 ! End of DELETE_EVENT

%routine ('CLEAN_UP') : NOVALUE =

!++
!
! Functional description:
!
!	CLEAN_UP is called by DELETE_EVENT, i.e. it is called when an
!	event has been deleted. CLEAN_UP will try to deallocate unused
!	data structures.
!
! Formal parameters:
!
!	None.
!
! Implicit inputs:
!
!	NB, the NICE block
!
! Returns:	NOVALUE
!
!--

   begin

   ! Start with entity layer
   if .NB[NB_EVENT_ENTITY_TYPE] neq NO_ENTITY_
   then begin                           ! Yes, there is an entity
        ! If filter became 0, then remove entity block
        if .EVENT_ENTITY_PTR[EVENT_ENTITY_FILTER] eql 0
        then begin
             ! Unlink it from queue and release memory
             NMU$QUEUE_EXTRACT(CLASS_FILTER_PTR[QH_EVENT_ENTITY],
                              .EVENT_ENTITY_PTR);
             RELEASE_MEMORY(.EVENT_ENTITY_PTR,EVENT_ENTITY_ALLOCATION);
             EVENT_ENTITY_PTR = 0;      ! Reset pointer also
             end;
        end;

   ! The entity has (possibly) been cleaned. Now check if the CLASS_BLOCK
   ! can be deallocated. It can if the following conditions are met:
   !  1. All global filters are zero
   !  2. All event entities lists/queues it points to are empty

   begin

   local I,                             ! Declare loop index
         CF_PTR : ref CLASS_FILTER_BLOCK;       ! And temporary pointer

   CF_PTR = CLASS_PTR[CLASS_FILTER_AREA];
   incr I from 0 to 7 do
        begin
        if (.CF_PTR[GLOBAL_FILTER] neq 0) or
           (NMU$QUEUE_LENGTH(CF_PTR[QH_EVENT_ENTITY]) neq 0)
        then return;                    ! Cannot deallocate, just return
        CF_PTR = .CF_PTR + CLASS_FILTER_SIZE;   ! Step forward
        end;
   end;

   ! If we get here, then we have passed all CLASS_BLOCK tests and its OK
   ! to deallocate.
   !
   ! Unlink from queue and release memory

   NMU$QUEUE_EXTRACT(.QH_CLASS, .CLASS_PTR);
   RELEASE_MEMORY(.CLASS_PTR, CLASS_ALLOCATION);
   CLASS_PTR = 0;                       ! Reset pointers
   CLASS_FILTER_PTR = 0;

   ! Now we may proceed and possibly remove the sink node block too..
   !
   ! The following conditions must be met for removing the sink node block:
   !     All queue headers (console, file, monitor) must point to empty
   !     queues.

   if NMU$QUEUE_LENGTH(SINK_NODE_PTR[QH_CONSOLE_CLASS]) neq 0 then return;
   if NMU$QUEUE_LENGTH(SINK_NODE_PTR[QH_FILE_CLASS]) neq 0 then return;
   if NMU$QUEUE_LENGTH(SINK_NODE_PTR[QH_MONITOR_CLASS]) neq 0 then return;

   ! Come here if all queues were empty: remove sink node block from sink
   ! node queue, and release memory.

   NMU$QUEUE_EXTRACT(QH_SINK_NODES, .SINK_NODE_PTR);
   RELEASE_MEMORY(.SINK_NODE_PTR, SINK_NODE_ALLOCATION);
   SINK_NODE_PTR = 0;                   ! Reset pointer too

   return;

   end;                                 ! End of CLEAN_UP

%routine('FIND_NEXT_CLASS') =

!++
!
! Functional description:
!
!     Searches for next non-zero event class, given a sink node and sink type.
!     
!     This routine is used by the CLEAR KNOWN EVENTS code.
!
!     Since this routine always start from the top of the tree,
!     care has to be taken to prevent a caller from looping forever,
!     i.e. the caller should delete the event class from the database.
!
! Routine value:
!
!     -1    No more event classes
!     >=0   Next non-zero event class
!
!--

   begin

   if (SINK_NODE_PTR = NMU$QUEUE_SCAN(QH_SINK_NODES,
                                      ch$ptr(NB[NB_SINK_NODE_ID],,8),
                                      SINK_NODE_MATCH)) eql 0
   then return -1;                      ! Sink node wasnt there

   case .NB[NB_SINK_TYPE] from LOGGING_LO to LOGGING_HI of
        set
        [CONSOLE_] : QH_CLASS = SINK_NODE_PTR[QH_CONSOLE_CLASS];
        [FILE_]    : QH_CLASS = SINK_NODE_PTR[QH_FILE_CLASS];
        [MONITOR_] : QH_CLASS = SINK_NODE_PTR[QH_MONITOR_CLASS];
        [outrange] : return -1;         ! In case....
        tes;

   ! Now loop over all class blocks for this class
   CLASS_PTR = 0;
   while ((CLASS_PTR = NMU$QUEUE_NEXT(.QH_CLASS, .CLASS_PTR)) neq 0) do
           begin

           local I;                     ! Loop count

           incr I from 0 to 7 do        ! Step over all classes within block
                begin

                CLASS_FILTER_PTR = CLASS_PTR[CLASS_FILTER_AREA] +
                                   .I * CLASS_FILTER_SIZE;

                if .NB[NB_EVENT_ENTITY_TYPE] eql NO_ENTITY_ then
                   begin
                   if .CLASS_FILTER_PTR[GLOBAL_FILTER] neq 0 then
                      return (.CLASS_PTR[CLASS_LOW] + .I);      ! Candidate
                   end
                else begin
                   ! Come here with an entity to look for
                     EVENT_ENTITY_PTR =
                           NMU$QUEUE_SCAN(CLASS_FILTER_PTR[QH_EVENT_ENTITY],
                                          NB, EVENT_ENTITY_MATCH);
                     if .EVENT_ENTITY_PTR neq 0 then
                        ! Event entity filter must be non-zero, otherwise it
                        ! would have been reaped before.
                        return (.CLASS_PTR[CLASS_LOW] + .I);    ! Candidate
                     end;
                end;
           end;

      return -1;                        ! No match found

      end;                              ! End of FIND_NEXT_CLASS

%global_routine ('NML$EVL_READ_EVENTS', ENTITY_PTR, QUALIFIER, SELECTOR,
                                          LENGTH, BUFFER_PTR) =

! DDT name: ED%REA

!++
!
! FUNCTIONAL DESCRIPTION
!
!	Read information from LOGGING database
!
! FORMAL PARAMETERS
!
!	ENTITY_PTR	Character sequence pointer to entity id.
!	QUALIFIER	Character sequence pointer to the qualifier parameter
!       SELECTOR        The class of entities to return
!	LENGTH		Address of a variable to be updated with the length
!			of the data returned in the buffer
!	BUFFER_PTR	Address of a character sequence pointer to parameter
!                       buffer
!
! ROUTINE VALUE
!
!	NICE return code
!
! SIDE EFFECTS
!
!	NONE
!
!--

!++
!
! Design notes:
!
!	[TBS]
!
!--

   begin

   local
        SAV_PTR;

   SAV_PTR = ..BUFFER_PTR;              ! Save return pointer

! Get logging sink type
   SB[SB_SINK_TYPE] = GETB(ENTITY_PTR);

! Fill in return byte pointer
   SB[SB_RETPTR] = .BUFFER_PTR;

! Set 'SENT SINK' zero meaning that sink node parameter has not yet been sent
   SB[SB_SINK_SENT] = 0;

! If qualifier exists, expand it. Else, default it to executor.
   if .QUALIFIER neq 0
   then if GETW(QUALIFIER) neq SINK_NODE_PARAMETER
        then return NICE$_IMF;

! Check the SINK NODE qualifier and do one of the following things:
!  If it is a single node spec, show events for that node
!  If it is KNOWN nodes, loop over all sink nodes and show events
!  If it is none of these, give 'Illegal message format'

   case NML$CONVERT_ENTITY_ID( ENTITY_NODE, QUALIFIER,
                               ch$ptr(SB[SB_SINK_NODE_ID],,8))
        from SIGNIFICANT_ to $true of

        set

        ! Unsupported options
        [SIGNIFICANT_, ADJACENT_, LOOPED_, ACTIVE_, $false] :
                       return NICE$_IMF;

        ! Single node
        [$true] : if ..LENGTH - ch$diff(..SB[SB_RETPTR],.SAV_PTR) geq 60
                  then begin
                       if SHOW_SINK_NODE() eql $false then return NICE$_MPE;
                       end
                  else return NICE$_REE;

        ! All known sink nodes
        [KNOWN_] :
            begin

            SINK_NODE_PTR = 0;
            while (SINK_NODE_PTR =
                   NMU$QUEUE_NEXT(QH_SINK_NODES, .SINK_NODE_PTR)) neq 0 do
                   begin
                   if ..LENGTH - ch$diff(..SB[SB_RETPTR],.SAV_PTR) lss 60
                   then return NICE$_REE;
                   ch$move(NODE_ID_BUFFER_LENGTH,
                           ch$ptr(SINK_NODE_PTR[SINK_NODE_NAME],,8),
                           ch$ptr(SB[SB_SINK_NODE_ID],,8));
                   SB[SB_SINK_SENT] = 0;        ! No sink parameter yet
                   if SHOW_SINK_NODE() eql $false then return NICE$_MPE;
                   end;
            end;
        tes;

! All well, update number of characters written
   .LENGTH = ..LENGTH - ch$diff(..SB[SB_RETPTR],.SAV_PTR);

   return NICE$_SUC;
   end;                                 ! End of routine NML$EVL_READ_EVENTS

%routine('SHOW_SINK_NODE') =

!++
!
! Functional description:
!
!    Find and show all events for a sink node and sink type.
!
! Formal parameters:
!
!    None
!
! Implicit inputs:
!
!    The SB block
!
! Implicit outputs:
!
!    Writes to the buffer specified by the character pointer in the SB
!
!--

   begin

! Find the sink node block associated with this sink node name
   SINK_NODE_PTR = NMU$QUEUE_SCAN(QH_SINK_NODES,
                                  ch$ptr(SB[SB_SINK_NODE_ID],,8),
                                  SINK_NODE_MATCH);
   if .SINK_NODE_PTR eql 0 then return $false;

! Come here with a pointer to the sink node block in SINK_NODE_PTR.
! Proceed to pick up the correct class queue header.

   case .SB[SB_SINK_TYPE] from LOGGING_LO to LOGGING_HI of
        set
        [CONSOLE_] : QH_CLASS = SINK_NODE_PTR[QH_CONSOLE_CLASS];
        [FILE_]    : QH_CLASS = SINK_NODE_PTR[QH_FILE_CLASS];
        [MONITOR_] : QH_CLASS = SINK_NODE_PTR[QH_MONITOR_CLASS];
        [outrange] : return $false;     ! In case...
        tes;

! Loop over all class blocks in this list
   CLASS_PTR = 0;
   while ((CLASS_PTR =
          NMU$QUEUE_NEXT(.QH_CLASS, .CLASS_PTR)) neq 0) do
   begin
        local
             I;                         ! Loop count

        incr I from 0 to 7 do           ! Loop over all classes within block
        begin
             CLASS_FILTER_PTR = CLASS_PTR[CLASS_FILTER_AREA] +
                                .I * CLASS_FILTER_SIZE;

             EVENT_ENTITY_PTR = 0;      ! Ensure this is zero
             if .CLASS_FILTER_PTR[GLOBAL_FILTER] neq 0
             then begin                 ! Report this global filter
                  EVENT_ENCODE(.I);     ! For easy calculation of class #
                  end;

             ! Now check if there are any event entities.
             while ((EVENT_ENTITY_PTR =
                     NMU$QUEUE_NEXT(CLASS_FILTER_PTR[QH_EVENT_ENTITY],
                                    .EVENT_ENTITY_PTR)) neq 0) do
             ! Note: if there is an event entity block, there is also
             ! a non-zero filter since CLEAN_UP otherwise would have
             ! removed the block.
             EVENT_ENCODE(.I);

        end;                            ! End of loop over all events within
                                        !  this class block

   end;                                 ! End loop over all class blocks

   return $true;

   end;

%routine('EVENT_ENCODE' , INDEX ) : novalue =

!++
!
! Functional description:
!
!    This routine will encode an event specification from the implicit
!    inputs in the SB block, and the global pointers.
!
! Formal parameters:
!
!    INDEX     The index within the class block for easy calculation of
!              the event class #. This parameter could be calculated from
!              the difference of the class filter pointer and the class
!              pointer but its easier this way...
!
! Implicit outputs:
!
!    Writes to the character buffer
!
!--

   begin

   local
        ENTYPE,                         ! Temporary entity type
        TEMP,                           ! Temporary
        TEMP_PTR;                       ! Temporary pointer

   ! First check whether the sink node parameter has been sent already
   if .SB[SB_SINK_SENT] eql 0
   then begin
        local TEMP,                          ! Temporary value
              TEMP_PTR;                      ! Temporary pointer

        SB[SB_SINK_SENT] = 1;           ! Flag that this has been done

! The layout is the following:
!  B:2       parameter #
!  B         CM-2 (302)
!  B         Unsigned 2 byte decimal # (002)
!  B:2       node address
!  100       AI-field
!  x         length of node name followed by node name string

        TEMP = SINK_NODE_PARAMETER;
        PUTW(TEMP,.SB[SB_RETPTR]);

        PUTB(%O'302',.SB[SB_RETPTR]);

        PUTB(%O'002',.SB[SB_RETPTR]);
        TEMP_PTR = ch$ptr(SB[SB_SINK_NODE_ID],,8);
        TEMP = GETW(TEMP_PTR);
        PUTW(TEMP,.SB[SB_RETPTR]);

        PUTB(%O'100',.SB[SB_RETPTR]);
        TEMP = GETB(TEMP_PTR);               ! Length
        PUTB(.TEMP,.SB[SB_RETPTR]);
        ch$move(.TEMP, .TEMP_PTR, ..SB[SB_RETPTR]);
        .SB[SB_RETPTR] = ch$plus(..SB[SB_RETPTR], .TEMP);    ! Update pointer

        end;

   ! The layout of the NICE return is the following:
   !
   !                       parameter #
   !
   !
   !   No entity         Circuit,line,module     Area      Node
   !     303 CM-3          304 CM-4                304       305 CM-5
   !     201 CS-1          201 CS-1                201       201 CS-1
   !     B:1 NO_ENTITY_    B:1 ENTITY_TYPE         B:1 area  B:1 ENTITY_TYPE
   !                       100 AI                  202       002 Unsigned 2
   !                       x   Entity ID           0         B:2 Node #
   !                                               area #    100 AI
   !                                                         x   Entity ID
   !
   !
   !                       002 Unsigned decimal 2 bytes     
   !                       B:2 Event class
   !                       040 Octal image
   !                       B:1 Length of octal image
   !                       n   Event filter bit mask

   TEMP = EVENT_PARAMETER;              ! Put out event parameter
   PUTW(TEMP, .SB[SB_RETPTR]);

   ENTYPE = (if .EVENT_ENTITY_PTR eql 0
             then NO_ENTITY_
             else .EVENT_ENTITY_PTR[EVENT_ENTITY_TYPE]);

   ! Output CM-3, CM-4 or CM-5 depending on entity type
   case .ENTYPE from NO_ENTITY_ to ENTITY_HI of
        set

        [NO_ENTITY_] : PUTB(%O'303', .SB[SB_RETPTR]);   ! CM-3
        [ENTITY_AREA, ENTITY_CIRCUIT, ENTITY_LINE, ENTITY_MODULE] :
                       PUTB(%O'304', .SB[SB_RETPTR]);   ! CM-4
        [ENTITY_NODE] : PUTB(%O'305', .SB[SB_RETPTR]);  ! CM-5
        [inrange, outrange] : return $false;    ! Shouldnt happen...

        tes;

   ! Output CS-1 (201) followed by entity type
   PUTB(%O'201', .SB[SB_RETPTR]);
   PUTB(.ENTYPE, .SB[SB_RETPTR]);

   ! Now output the entity ID depending on entity type
   !  (NO_ENTITY_ not included since there is no entity type to type out)
   case .ENTYPE from NO_ENTITY_ to ENTITY_HI of
        set

        [ENTITY_AREA] :
                begin
                    PUTB(%O'202', .SB[SB_RETPTR]);      ! CS-2
                    PUTB(0, .SB[SB_RETPTR]);            ! Byte 0 is zero
                    PUTB(GETB(ch$ptr(EVENT_ENTITY_PTR[EVENT_ENTITY_ID],,8)),
                            .SB[SB_RETPTR]);
                    end;

        [ENTITY_CIRCUIT, ENTITY_LINE, ENTITY_MODULE] :
                begin
                    PUTB(%O'100', .SB[SB_RETPTR]);      ! AI
                    TEMP_PTR = ch$ptr(EVENT_ENTITY_PTR[EVENT_ENTITY_ID],,8);
                    TEMP = GETB(TEMP_PTR);
                    PUTB(.TEMP, .SB[SB_RETPTR]);
                    ch$move(.TEMP, .TEMP_PTR, ..SB[SB_RETPTR]);
                    .SB[SB_RETPTR] = ch$plus(..SB[SB_RETPTR], .TEMP);
                    end;
                    
        [ENTITY_NODE] :
                begin
                    PUTB(%O'002', .SB[SB_RETPTR]);      ! 2 byte #
                    TEMP_PTR = ch$ptr(EVENT_ENTITY_PTR[EVENT_ENTITY_ID],,8);
                    TEMP = GETW(TEMP_PTR);              ! Get node #
                    PUTW(TEMP, .SB[SB_RETPTR]);
                    PUTB(%O'100', .SB[SB_RETPTR]);      ! AI
                    TEMP = GETB(TEMP_PTR);
                    PUTB(.TEMP, .SB[SB_RETPTR]);
                    ch$move(.TEMP, .TEMP_PTR, ..SB[SB_RETPTR]);
                    .SB[SB_RETPTR] = ch$plus(..SB[SB_RETPTR], .TEMP);
                    end;

        [inrange] : ;

        tes;

! Now output the event class and event type fields

   PUTB(%O'002', .SB[SB_RETPTR]);       ! 2 unsigned decimal bytes
   TEMP = .CLASS_PTR[CLASS_LOW] + .INDEX;
   PUTW(TEMP, .SB[SB_RETPTR]);

   ! Now put out the filter
   begin
        local FILTER, COUNT;

        PUTB(%O'040', .SB[SB_RETPTR]);       ! Octal image field

        FILTER = (if .EVENT_ENTITY_PTR neq 0
                  then .EVENT_ENTITY_PTR[EVENT_ENTITY_FILTER]
                  else .CLASS_FILTER_PTR[GLOBAL_FILTER]);

        COUNT = (if .FILTER<24,8,0> neq 0 then 4
                 else if .FILTER<16,8,0> neq 0 then 3
                 else if .FILTER<8,8,0> neq 0 then 2
                 else if .FILTER<0,8,0> neq 0 then 1
                 else 0);

        PUTB(.COUNT, .SB[SB_RETPTR]);   ! Output # of event bytes

        if .COUNT geq 1 then PUTB(.FILTER<0,8,0>, .SB[SB_RETPTR]);
        if .COUNT geq 2 then PUTB(.FILTER<8,8,0>, .SB[SB_RETPTR]);
        if .COUNT geq 3 then PUTB(.FILTER<16,8,0>, .SB[SB_RETPTR]);
        if .COUNT geq 4 then PUTB(.FILTER<24,8,0>, .SB[SB_RETPTR]);

        end;

   return;

   end;

%global_routine('NML$EVL_APPLY_FILTER', SINK_FLAGS, EVENT_CODE, ENTITY_TYPE,
                                          ENTITY_ID, CALLER_DATA, CALL_BACK) =

! DDT name: ED%FIL

!++
!
! Functional description:
!
!	NML$EVL_APPLY_FILTER searches the event data base for filters that
!	match a given event.
!
! Formal parameters to NML$EVL_APPLY_FILTER:
!
!	SINK_FLAGS	the sink types that should be tested (normally all
!			sink types). B0 means console, B1 file, B2 monitor.
!	EVENT_CODE	the event class and type. The event class is in bits
!			6-14, while the type is in bits 0-4.
!	ENTITY_TYPE	contains the entity type
!	ENTITY_ID	character sequence pointer to entity ID
!       CALLER_DATA     data that the caller supplies that is added as argument
!                       to the callback routine. NML$EVL_APPLY_FILTER does not
!                       touch this field.
!	CALL_BACK	routine to call back on matches
!
! Returns:
!	$false	Something went wrong
!	$true	All well
!
!--

!++
!
! Design notes:
!
!	NML$EVL_APPLY_FILTER is the routine that makes the filtering decisions.
!	Based on the input provided by the EVENT_PROCESSOR in NMLEVL the
!	routine scans the data base. 
!
!	The routine scans all sink types on all sink nodes. When a match is
!	found, the callback routine in the EVENT_PROCESSOR is called to log
!	the event.
!
!	The callback routine will be called once for each node for which
!	there is a match.
!
!	The callback routine is called in the following way:
!        CALLBACK(SINK_FLAGS, LOCAL_DESTINATION, DESTINATION_NODE, CALLER_DATA)
!	where
!
!		SINK_FLAGS	the sink types on this sink that should
!				receive a copy of the event.
!
!		LOCAL_DESTINATION	a flag that, if set, means that the
!					destination is the local node
!
!		DESTINATION_NODE	a character pointer to the destination
!					node name string.
!
!               CALLER_DATA             the data the caller supplied
!
!	The callback routine is expected to return $TRUE. If it does not,
!	the scan through the data base is stopped, and APPLY_FILTER returns
!	immediately.
!
!       Event 0.0 ("Event records lost") must be treated in a special way.
!       The architecture prescribes that event 0.0 is thrown away only if
!       i) logging is turned off for event 0.0 and ii) all other events
!       are turned off. Hence, a special test is made for event 0.0
!
!	1. The values of the arguments to NML$EVL_APPLY_FILTER are written
!	   to the FILTER_BLOCK.
!	2. The routine loops over all sink nodes, calling SEARCH_FILTER
!	   for each sink (console, file, monitor) on each sink node.
!	3. SEARCH_FILTER loops over all class blocks and class entity blocks
!	   (the latter if appropriate) to find a matching filter.
!          If it happens to be event 0.0 return $true always unless no other
!          filter is enabled.
!	4. SEARCH_FILTER returns TRUE to NML$EVL_APPLY_FILTER if a filter
!	   was found and the event was not filtered.
!	5. NML$EVL_APPLY_FILTER notes the return of SEARCH_FILTER. When all
!	   sinks for a particular node has been checked, NML$EVL_APPLY_FILTER
!	   checks if there was a TRUE return from any of the sinks. If so,
!	   the event should be logged at the particular sink node and the
!	   callback routine supplied by EVENT_PROCESSOR is called.
!
!--

   begin

   bind routine CALL_BACK_ROUTINE = .CALL_BACK;

   local sink_types;                    ! Bit 0 = console, 1 = file,
                                        !     2 = monitor

   ! Step 1 is to set the filter block.
   FB[FB_SINK_FLAGS] = .SINK_FLAGS<SINK_MASK>;      ! Get sink bits
   FB[FB_EV_0_0] = (.EVENT_CODE<$$EVENT_CLASS> eql 0)
                    and (.EVENT_CODE<$$EVENT_TYPE> eql 0);
   FB[FB_EVENT_CLASS] = .EVENT_CODE<$$EVENT_CLASS>;
   FB[FB_EVENT_FILTER] = 1 ^ .EVENT_CODE<$$EVENT_TYPE>;
                                                        ! into bit position
   FB[FB_ENTITY_TYPE] = .ENTITY_TYPE;   ! Entity type

   begin
        local temp;
        temp = .ENTITY_ID;                   ! NML$CONVERT_ENTITY_ID changes
                                             ! input ptr
        if NML$CONVERT_ENTITY_ID(.ENTITY_TYPE, temp,
               ch$ptr(FB[FB_ENTITY_ID],,8)) neq $true then return $false;
        end;

   ! The FB has now been initialized.

   SINK_NODE_PTR = 0;
   while (SINK_NODE_PTR =
         NMU$QUEUE_NEXT(QH_SINK_NODES, .SINK_NODE_PTR)) neq 0 do
         begin
         
         SINK_TYPES<SINK_MASK> = 0;         ! Clear out sink types

         ! Now call SEARCH_EVENT for each sink type
         if .FB[FB_SINK_CONSOLE] neq 0
         then begin
              QH_CLASS = SINK_NODE_PTR[QH_CONSOLE_CLASS];
              SINK_TYPES<CONSOLE_MASK> = SEARCH_FILTER();
              end;
         if .FB[FB_SINK_FILE] neq 0
         then begin
              QH_CLASS = SINK_NODE_PTR[QH_FILE_CLASS];
              SINK_TYPES<FILE_MASK> = SEARCH_FILTER();
              end;
         if .FB[FB_SINK_MONITOR] neq 0
         then begin
              QH_CLASS = SINK_NODE_PTR[QH_MONITOR_CLASS];
              SINK_TYPES<MONITOR_MASK> = SEARCH_FILTER();
              end;

         ! If any sink type has signalled, log the event through the
         ! callback routine.
         if .SINK_TYPES<SINK_MASK> neq 0
         then begin
              if CALL_BACK_ROUTINE(.SINK_TYPES<SINK_MASK>,
                                   .SINK_NODE_PTR[SINK_NODE_LOCAL],
                                   ch$ptr(SINK_NODE_PTR[SINK_NODE_NAME],,8),
                                   .CALLER_DATA)
              neq $true
              then return $false;
              end;
         
         ! Loop back
         end;                           ! End WHILE...DO

   return $true;

   end;                                 ! End of NML$EVL_APPLY_FILTER

%routine('SEARCH_FILTER') = 

!++
!
! Functional description:
!
!	SEARCH_FILTER is called to search a list of class blocks for
!	a match. 
!
! Formal parameters:
!
!	None
!
! Implicit inputs:
!
!	FB, the FILTER_BLOCK.
!       Also assumes QH_CLASS is set up.
!
! Returns:
!
!	$false	No match
!	$true	Match
!
!--

   begin

   ! Find the class block that describes this class
   CLASS_PTR = NMU$QUEUE_SCAN(.QH_CLASS, .FB[FB_EVENT_CLASS], CLASS_MATCH);
   if .CLASS_PTR eql 0 then return $false;      ! No match at all here

   ! Coming here we know that there is some event turned on (CLASS_PTR =/= 0)
   !  => event 0.0 should be logged
   if .FB[FB_EV_0_0] then return $true;

   ! Find the class filter for this event class within the class block
   CLASS_FILTER_PTR =
         CLASS_PTR[CLASS_FILTER_AREA] +
         (.FB[FB_EVENT_CLASS] - .CLASS_PTR[CLASS_LOW]) * CLASS_FILTER_SIZE;

   ! If there is no entity, apply global filter. If there is an entity,
   ! search entity list for a match.
   if .FB[FB_ENTITY_TYPE] eql NO_ENTITY_
   then begin
        if (.CLASS_FILTER_PTR[GLOBAL_FILTER] and .FB[FB_EVENT_FILTER]) neq 0
        then return $true;              ! Match
        end
   else begin                           ! Search entity queues for a match

        ! There is an entity specifier, search for it in entity lists.
        EVENT_ENTITY_PTR =
              NMU$QUEUE_SCAN(CLASS_FILTER_PTR[QH_EVENT_ENTITY],
                             FB,
                             ENTITY_FILTER_MATCH);
        if .EVENT_ENTITY_PTR eql 0
        then begin                      ! No entity matched, try global filter
             if (.CLASS_FILTER_PTR[GLOBAL_FILTER] and
                 .FB[FB_EVENT_FILTER]) neq 0
             then return $true;
             end
        else begin                      ! There was an entity, try its filter
             if (.EVENT_ENTITY_PTR[EVENT_ENTITY_FILTER] and
                 .FB[FB_EVENT_FILTER]) neq 0 then return $true;
             end;
        end;

   ! If we fall out here, then no match have been made:

   return $false;

   end;                                 ! End of SEARCH_FILTER

%global_routine ('NML$EVL_EVENT_TEXT', EVENT_CLASS, EVENT_TYPE) =

! DDT name: ED%ETX

!++
!
! Functional description:
!
!    This routine retrieves the event text associated with an event
!    parameter.
!
! Formal parameters:
!
!    EVENT_CLASS     The event class
!    EVENT_TYPE      The event type
!
! Returns:   0       Event not found
!            ptr     Character pointer to event text
!
!--

   begin

   local I;                             ! Loop index

   incr I from 0 to NR_EVENTS - 1
        do 
           if (.EVENT_TABLE[ .I, EV_CLASS] eql .EVENT_CLASS)
              and (.EVENT_TABLE[ .I, EV_TYPE] eql .EVENT_TYPE)
           then return .EVENT_TABLE[ .I, EV_TEXT];

   ! Come here on no match
   return 0;

   end;                                 ! End of NML$EVL_EVENT_TEXT

%global_routine ('NML$EVL_SET_VDB_PARAMETER', ENTITY_TYPE, ENTITY_PTR,
                                                PARM_NO, DATA_ADDR) =

! DDT name: ED%SET

!++
! FUNCTIONAL DESCRIPTION:
!
!	Inserts the data for a logging parameter into the event logger
!	volatile data base. The value of the parameter is stored at the
!	address specified by DATA_ADDR
!
! FORMAL PARAMETERS
!
!	ENTITY_TYPE	Entity type
!	ENTITY_PTR	Character pointer to entity id
!	PARM_NO		The parameter number
!	DATA_ADDR	Address of data of value
!
! IMPLICIT INPUTS
!
!	NONE
!
! ROUTINE VALUE
!
!	TRUE		If the parameter was set
!	FALSE		If not,
!
! SIDE EFFECTS
!
!	NONE
!
!--

   begin

   TASK_INFO('INTERNAL ERROR: NML$EVL_SET_VDB_PARAMETER erroneously called');
   return $TRUE
   end;                                 ! End of NML$EVL_SET_VDB_PARAMETER

%global_routine ('NML$EVL_CLR_VDB_PARAMETER', ENTITY_TYPE, ENTITY_PTR,
                                                PARM_NO) =

! DDT name: ED%CLR

!++
! FUNCTIONAL DESCRIPTION:
!
!       Removes a logging parameter from the logging database
!
! FORMAL PARAMETERS
!
!	ENTITY_TYPE	Entity type
!	ENTITY_PTR	Character pointer to entity id
!	PARM_NO		The parameter number
!
! IMPLICIT INPUTS
!
!	NONE
!
! ROUTINE VALUE
!
!	TRUE		If the parameter was set
!	FALSE		If not,
!
! SIDE EFFECTS
!
!	NONE
!
!--

   begin

   TASK_INFO('INTERNAL ERROR: NML$EVL_CLR_VDB_PARAMETER erroneously called');
   return $TRUE
   end;                                 ! End of NML$EVL_CLR_VDB_PARAMETER

%global_routine ('NML$EVL_GET_VDB_PARAMETER', ENTITY_TYPE, ENTITY_PTR,
                                                PARM_NO, DATA_ADDR) =

! DDT name: ED%GET

!++
! FUNCTIONAL DESCRIPTION:
!
!	Reads a parameter from the event logger data base. On return,
!	the parameter value is stored at the address specified by DATA_ADDR.
!
! FORMAL PARAMETERS
!
!	ENTITY_TYPE	Entity type
!	ENTITY_PTR	Character pointer to entity id
!	PARM_NO		The parameter number
!	DATA_ADDR	Address of buffer where parameter value is returned
!
! IMPLICIT INPUTS
!
!	NONE
!
! ROUTINE VALUE
!
!	TRUE		If the parameter was set
!	FALSE		If not,
!
! SIDE EFFECTS
!
!	NONE
!
!--

   begin

   TASK_INFO('INTERNAL ERROR: NML$EVL_GET_VDB_PARAMETER erroneously called');
   return $TRUE
   end;                                 ! End of NML$EVL_GET_VDB_PARAMETER

%routine ('SINK_NODE_MATCH' , QE_SINK_NODE, NAME_PTR) = 

!++
!
! Functional description:
!
!	This is a NMU$QUEUE_SCAN match routine. It is called when searching
!	the SINK NODE list. Therefore, QE_SINK_NODE is the current entry in
!	the list. The NAME_PTR points to the sink node name string to compare
!	with. This string will always be equal to the sink node name in the
!	NB block.
!
! Formal parameters:
!
!	QE_SINK_NODE	Points to entry to be tested in SINK NODE list 
!	NAME_PTR	Character sequence pointer to name string
!
! Returns:
!	0	No match
!       <>0	Address of matching entry in queue.
!
!--

   begin

   map QE_SINK_NODE : ref SINK_NODE_BLOCK;      ! Declare

   if ch$eql(NODE_ID_BUFFER_LENGTH, ch$ptr(QE_SINK_NODE[SINK_NODE_NAME],,8),
             NODE_ID_BUFFER_LENGTH, .NAME_PTR,0) eql 0
   then return 0
   else return .QE_SINK_NODE;

   end;                                 ! End of SINK_NODE_MATCH

%routine('CLASS_MATCH', QE_CLASS, CLASS_NR) = 

!++
!
! Functional description:
!
!	This is a NMU$QUEUE_SCAN match routine. It is called when searching
!	the CLASS list. A match is made if the CLASS_NR is in the class
!	range supported by the current class block QE_CLASS.
!
! Formal parameters:
!
!	QE_CLASS	Points to class block entry
!	CLASS_NR	The class number that is searched for
!
! Returns:
!	0	no match
!	<>0	Address of matching class block entry
!
!--

   begin

   map QE_CLASS : ref CLASS_BLOCK;

   if (.QE_CLASS[CLASS_LOW] leq .CLASS_NR)
   and (.CLASS_NR leq .QE_CLASS[CLASS_HIGH])
   then return .QE_CLASS
   else return 0;

   end;

%routine('EVENT_ENTITY_MATCH' , QE_EVENT_ENTITY, NB_PTR) =

!++
!
! Functional description:
!
!	This is a NMU$QUEUE_SCAN match routine. It is called when searching
!	the EVENT ENTITY list. A match is made if the NICE BLOCK that NB_PTR
!	points to contains an entity type and id that matches the entity
!	supplied in the EVENT ENTITY block that QE_EVENT_ENTITY points to.
!
! Formal parameters:
!
!	QE_EVENT_ENTITY		Points to event entity block entry
!	NB_PTR			Points to NB block
!
! Returns:
!
!	0	no match
!	<>0	Address of matching event entity block
!
!--

   begin

   map QE_EVENT_ENTITY : ref EVENT_ENTITY_BLOCK,
       NB_PTR          : ref NICE_BLOCK;

   if (.NB_PTR[NB_EVENT_ENTITY_TYPE] eql .QE_EVENT_ENTITY[EVENT_ENTITY_TYPE])
      and (ch$eql(2 + max(0,9,17), ch$ptr(NB_PTR[NB_EVENT_ENTITY_ID],,8),
                  2 + max(0,9,17), ch$ptr(QE_EVENT_ENTITY[EVENT_ENTITY_ID],,8),
                  0) neq 0) then return .QE_EVENT_ENTITY else return 0;

   end;                                 ! End of EVENT_ENTITY_MATCH

%routine('ENTITY_FILTER_MATCH' , QE_EVENT_ENTITY, FB_PTR) =

!++
!
! Functional description:
!
!	This is a NMU$QUEUE_SCAN match routine. It is called when searching
!	the EVENT ENTITY list. A match is made if the FILTER BLOCK that FB_PTR
!	points to contains an entity type and id that matches the entity
!	supplied in the EVENT ENTITY block that QE_EVENT_ENTITY points to.
!
! Formal parameters:
!
!	QE_EVENT_ENTITY		Points to event entity block entry
!       FB_PTR                  Points to filter block
!
! Returns:
!
!	0	no match
!	<>0	Address of matching event entity block
!
!--

   begin

   map QE_EVENT_ENTITY : ref EVENT_ENTITY_BLOCK,
       FB_PTR          : ref FILTER_BLOCK;

   if (.FB_PTR[FB_ENTITY_TYPE] eql .QE_EVENT_ENTITY[EVENT_ENTITY_TYPE])
      and (ch$eql(2 + max(0,9,17), ch$ptr(FB_PTR[FB_ENTITY_ID],,8),
                  2 + max(0,9,17), ch$ptr(QE_EVENT_ENTITY[EVENT_ENTITY_ID],,8),
                  0) neq 0) then return .QE_EVENT_ENTITY else return 0;

   end;                                 ! End of ENTITY_FILTER_MATCH

%routine ('GET_MEMORY' , ALLOCATION) =

!++
! Functional description:
!
!	This routine is called by all NMLVDE routines to allocate
!	memory. In future, it could be enhanced to control the memory
!	used by the event logging data base.
!
! Formal parameters:
!
!	ALLOCATION	- allocation units to allocate
!
! Routine value:
!	The address of the allocated block or 0
!
!--

   begin
   return NMU$MEMORY_GET(.ALLOCATION)
   end;

%routine ('RELEASE_MEMORY' , STORAGE_ADDRESS , ALLOCATION) : NOVALUE  =

!++
! Functional description:
!
!	This routine deallocates memory used by the event logger data base.
!
! Formal parameters:
!
!	STORAGE_ADDRESS		address of block to release
!	ALLOCATION		# of allocation units to release
!
! Routine value: NOVALUE
!
!--
   begin
   NMU$MEMORY_RELEASE (.STORAGE_ADDRESS, .ALLOCATION);
   end;

end                                     ! End of module NMLEVD
eludom
! Local Modes:
! Mode:BLISS
! Auto Save Mode:1
! Comment Column:40
! Comment Rounding:+1
! End: