Google
 

Trailing-Edge - PDP-10 Archives - bb-r775d-bm_tops20_ks_upd_4 - sources/chmkeywrd.bli
There are 11 other files named chmkeywrd.bli in the archive. Click here to see a list.
 %TITLE 'CHMKEYWRD - look for a keyword'
MODULE CHMKEYWRD (				! Look for a keyword
		IDENT = '3-002'			! File: CHMKEYWRD.BLI Edit: GB3002
		) =
BEGIN
!
!			  COPYRIGHT (c) 1981, 1985 BY
!	      DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS.
!		ALL RIGHTS RESERVED.
!
! 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:	EDT -- The DEC Standard Editor
!
! ABSTRACT:
!
!	This module compares the command buffer contents to a table
!	of keywords.
!
! ENVIRONMENT:	Runs at any access mode - AST reentrant
!
! AUTHOR: Bob Kushlis, CREATION DATE: Unknown
!
! MODIFIED BY:
!
! 1-001	- Original.  DJS 04-Feb-1981.  This module was created by
!	extracting the routine EDT$$KWORD  from module CHANGE.BLI.
! 1-002	- Regularize headers.  JBS 03-Mar-1981
! 1-004 - Change to a table arranged alphabetically. STS 21-Sep-1982
! 1-005	- Move the keywords here from EDT$CHMPARSE, to reduce the program
!	   size on the PDP-11.  Also, put an underscore in the entry point name.  JBS 29-Sep-1982
! 1-006	- Accept lower case letters as equivalent to upper case, and improve error
!	   checking.  JBS 01-Oct-1982
! 1-007	- Make this routine position-independent.  JBS 01-Oct-1982
! 1-008	- Add conditionals for WPS and VT220.  JBS 10-Feb-1983
! 1-009	- Don't forget the SUPPORTS library.  JBS 11-Feb-1983
! 3-002 - Remove VT220 conditional to speed up code. CJG 25-Nov-1983
!--

%SBTTL 'Declarations'
!
! TABLE OF CONTENTS:
!

REQUIRE 'EDTSRC:TRAROUNAM';

FORWARD ROUTINE
    EDT$$KEY_WORD : NOVALUE;			! Compare the command buffer contents to a table of keywords

!
! INCLUDE FILES:
!

REQUIRE 'EDTSRC:EDTREQ';

LIBRARY 'EDTSRC:TRANSLATE';

!
! MACROS:
!
!	NONE
!
! EQUATED SYMBOLS:
!

FIELD
    KEY_WORD_FIELD =
	SET
	KEY_WORD_NEXT = [0, 0, 18, 0],
	KEY_WORD_NUM = [0, 18, 9, 0],
	KEY_WORD_LEN = [0, 27, 9, 0],
	KEY_WORD_POINTER = [1, 0, 36, 0]
	TES;
LITERAL
	V_FIELD = %O'1000000',
	L_FIELD = %O'1000000000';

!
! OWN STORAGE:
!
!+
! Define the keywords used to make up change mode sub-commands.
!
! Each record in this table contains a address pointer to the next keyword
! with this alphabetic character  the value of the keyword, its length,
! and the ASCII characters which comprise it.
!
! The table is a concatenation of keyword entries.  Each
! consists of a pointer to the next keyword to examine if
! this one should fail, a keyword number byte, length byte,
! and the ASCII text for the keyword.  A 0 length byte
! marks the end of the table.  Letters in keywords are
! all upper case.
!-

BIND
    ADDR_BASE = UPLIT (0),
    END_VERBS = UPLIT (0, 0),

    ASC_VERB = UPLIT (
	END_VERBS - ADDR_BASE + V_FIELD * (VERB_K_ASC) + L_FIELD * (3), CH$PTR (UPLIT ('ASC'))),
    ADV_VERB = UPLIT (
	ASC_VERB - ADDR_BASE + V_FIELD * (VERB_K_ADV) + L_FIELD * (3), CH$PTR (UPLIT ('ADV'))),
    A_VERBS = UPLIT (
	ADV_VERB - ADDR_BASE + V_FIELD * (VERB_K_APPEND) + L_FIELD * (6), CH$PTR (UPLIT ('APPEND'))),
    BELL_VERB = UPLIT (
	END_VERBS - ADDR_BASE + V_FIELD * (VERB_K_BELL) + L_FIELD * (4), CH$PTR (UPLIT ('BELL'))),
    B_VERBS = UPLIT (
	BELL_VERB - ADDR_BASE + V_FIELD * (VERB_K_BACK) + L_FIELD * (4), CH$PTR (UPLIT ('BACK'))),
    CUT_VERB = UPLIT (
	END_VERBS - ADDR_BASE + V_FIELD * (VERB_K_CUT) + L_FIELD * (3), CH$PTR (UPLIT ('CUT'))),
    CLSS_VERB = UPLIT (
	CUT_VERB - ADDR_BASE + V_FIELD * (VERB_K_CLSS) + L_FIELD * (4), CH$PTR (UPLIT ('CLSS'))),
    CHGL_VERB = UPLIT (
	CLSS_VERB - ADDR_BASE + V_FIELD * (VERB_K_CHGL) + L_FIELD * (4), CH$PTR (UPLIT ('CHGL'))),
    CHGU_VERB = UPLIT (
	CHGL_VERB - ADDR_BASE + V_FIELD * (VERB_K_CHGU) + L_FIELD * (4), CH$PTR (UPLIT ('CHGU'))),
    C_VERBS = UPLIT (
	CHGU_VERB - ADDR_BASE + V_FIELD * (VERB_K_CHGC) + L_FIELD * (4), CH$PTR (UPLIT ('CHGC'))),
    D_VERB = UPLIT (
	END_VERBS - ADDR_BASE + V_FIELD * (VERB_K_DELETE) + L_FIELD * (1), CH$PTR (UPLIT ('D'))),
    DUPC_VERB = UPLIT (
	D_VERB - ADDR_BASE + V_FIELD * (VERB_K_DUPC) + L_FIELD * (4), CH$PTR (UPLIT ('DUPC'))),
    DMOV_VERB = UPLIT (
	DUPC_VERB - ADDR_BASE + V_FIELD * (VERB_K_DMOV) + L_FIELD * (4), CH$PTR (UPLIT ('DMOV'))),
    DLWC_VERB = UPLIT (
	DMOV_VERB - ADDR_BASE + V_FIELD * (VERB_K_DLWC) + L_FIELD * (4), CH$PTR (UPLIT ('DLWC'))),
    DEFK_VERB = UPLIT (
	DLWC_VERB - ADDR_BASE + V_FIELD * (VERB_K_DEFK) + L_FIELD * (4), CH$PTR (UPLIT ('DEFK'))),
    DATE_VERB = UPLIT (
	DEFK_VERB - ADDR_BASE + V_FIELD * (VERB_K_DATE) + L_FIELD * (4), CH$PTR (UPLIT ('DATE'))),
    D_VERBS = UPLIT (
	DATE_VERB - ADDR_BASE + V_FIELD * (VERB_K_DESEL) + L_FIELD * (5), CH$PTR (UPLIT ('DESEL'))),
    EX_VERB = UPLIT (
	END_VERBS - ADDR_BASE + V_FIELD * (VERB_K_EXIT) + L_FIELD * (2), CH$PTR (UPLIT ('EX'))),
    E_VERBS = UPLIT (
	EX_VERB - ADDR_BASE + V_FIELD * (VERB_K_EXT) + L_FIELD * (3), CH$PTR (UPLIT ('EXT'))),
    F_VERBS = UPLIT (
	END_VERBS - ADDR_BASE + V_FIELD * (VERB_K_FILL) + L_FIELD * (4), CH$PTR (UPLIT ('FILL'))),
    H_VERBS = UPLIT (
	END_VERBS - ADDR_BASE + V_FIELD * (VERB_K_HELP) + L_FIELD * (4), CH$PTR (UPLIT ('HELP'))),
    I_VERBS = UPLIT (
	END_VERBS - ADDR_BASE + V_FIELD * (VERB_K_INSERT) + L_FIELD * (1), CH$PTR (UPLIT ('I'))),
    K_VERBS = UPLIT (
	END_VERBS - ADDR_BASE + V_FIELD * (VERB_K_KS) + L_FIELD * (2), CH$PTR (UPLIT ('KS'))),
    P_VERBS = UPLIT (
	END_VERBS - ADDR_BASE + V_FIELD * (VERB_K_PASTE) + L_FIELD * (5), CH$PTR (UPLIT ('PASTE'))),
    Q_VERBS = UPLIT (
	END_VERBS - ADDR_BASE + V_FIELD * (VERB_K_QUIT) + L_FIELD * (4), CH$PTR (UPLIT ('QUIT'))),
    R_VERB = UPLIT (
	END_VERBS - ADDR_BASE + V_FIELD * (VERB_K_REPLACE) + L_FIELD * (1), CH$PTR (UPLIT ('R'))),
    R_VERBS = UPLIT (
	R_VERB - ADDR_BASE + V_FIELD * (VERB_K_REF) + L_FIELD * (3), CH$PTR (UPLIT ('REF'))),
    S_VERB = UPLIT (
	END_VERBS - ADDR_BASE + V_FIELD * (VERB_K_SUBS) + L_FIELD * (1), CH$PTR (UPLIT ('S'))),
    SN_VERB = UPLIT (
	S_VERB - ADDR_BASE + V_FIELD * (VERB_K_SN) + L_FIELD * (2), CH$PTR (UPLIT ('SN'))),
    SHR_VERB = UPLIT (
	SN_VERB - ADDR_BASE + V_FIELD * (VERB_K_SHR) + L_FIELD * (3), CH$PTR (UPLIT ('SHR'))),
    SHL_VERB = UPLIT (
	SHR_VERB - ADDR_BASE + V_FIELD * (VERB_K_SHL) + L_FIELD * (3), CH$PTR (UPLIT ('SHL'))),
    SEL_VERB = UPLIT (
	SHL_VERB - ADDR_BASE + V_FIELD * (VERB_K_SEL) + L_FIELD * (3), CH$PTR (UPLIT ('SEL'))),
    S_VERBS = UPLIT (
	SEL_VERB - ADDR_BASE + V_FIELD * (VERB_K_SSEL) + L_FIELD * (4), CH$PTR (UPLIT ('SSEL'))),
    TI_VERB = UPLIT (
	END_VERBS - ADDR_BASE + V_FIELD * (VERB_K_TI) + L_FIELD * (2), CH$PTR (UPLIT ('TI'))),
    TD_VERB = UPLIT (
	TI_VERB - ADDR_BASE + V_FIELD * (VERB_K_TD) + L_FIELD * (2), CH$PTR (UPLIT ('TD'))),
    TC_VERB = UPLIT (
	TD_VERB - ADDR_BASE + V_FIELD * (VERB_K_TC) + L_FIELD * (2), CH$PTR (UPLIT ('TC'))),
    TOP_VERB = UPLIT (
	TC_VERB - ADDR_BASE + V_FIELD * (VERB_K_TOP) + L_FIELD * (3), CH$PTR (UPLIT ('TOP'))),
    TAB_VERB = UPLIT (
	TOP_VERB - ADDR_BASE + V_FIELD * (VERB_K_TAB) + L_FIELD * (3), CH$PTR (UPLIT ('TAB'))),
    TADJ_VERB = UPLIT (
	TAB_VERB - ADDR_BASE + V_FIELD * (VERB_K_TADJ) + L_FIELD * (4), CH$PTR (UPLIT ('TADJ'))),
    T_VERBS = UPLIT (
	TADJ_VERB - ADDR_BASE + V_FIELD * (VERB_K_TGSEL) + L_FIELD * (5), CH$PTR (UPLIT ('TGSEL'))),
    UNDW_VERB = UPLIT (
	END_VERBS - ADDR_BASE + V_FIELD * (VERB_K_UNDW) + L_FIELD * (4), CH$PTR (UPLIT ('UNDW'))),
    UNDL_VERB = UPLIT (
  	UNDW_VERB - ADDR_BASE + V_FIELD * (VERB_K_UNDL) + L_FIELD * (4), CH$PTR (UPLIT ('UNDL'))),
    U_VERBS = UPLIT (
	UNDL_VERB - ADDR_BASE + V_FIELD * (VERB_K_UNDC) + L_FIELD * (4), CH$PTR (UPLIT ('UNDC'))),
    X_VERBS = UPLIT (
	END_VERBS - ADDR_BASE + V_FIELD * (VERB_K_XLATE) + L_FIELD * (5), CH$PTR (UPLIT ('XLATE'))),
    CARET_VERB = UPLIT (
	END_VERBS - ADDR_BASE + V_FIELD * (VERB_K_CC) + L_FIELD * (1), CH$PTR (UPLIT ('^')));

BIND
    VERB_TABLE = UPLIT (
	A_VERBS - ADDR_BASE,
	B_VERBS - ADDR_BASE,
	C_VERBS - ADDR_BASE,
	D_VERBS - ADDR_BASE,
	E_VERBS - ADDR_BASE,
	F_VERBS - ADDR_BASE,
	END_VERBS - ADDR_BASE,
	H_VERBS - ADDR_BASE,
	I_VERBS - ADDR_BASE,
	END_VERBS - ADDR_BASE,
	K_VERBS - ADDR_BASE,
	END_VERBS - ADDR_BASE,
	END_VERBS - ADDR_BASE,
	END_VERBS - ADDR_BASE,
	END_VERBS - ADDR_BASE,
	P_VERBS - ADDR_BASE,
	Q_VERBS - ADDR_BASE,
	R_VERBS - ADDR_BASE,
	S_VERBS - ADDR_BASE,
	T_VERBS - ADDR_BASE,
	U_VERBS - ADDR_BASE,
	END_VERBS - ADDR_BASE,
	END_VERBS - ADDR_BASE,
	X_VERBS - ADDR_BASE,
	END_VERBS - ADDR_BASE,
	END_VERBS - ADDR_BASE,
	END_VERBS - ADDR_BASE,
	END_VERBS - ADDR_BASE,
	END_VERBS - ADDR_BASE,
	CARET_VERB - ADDR_BASE);

!+
! The following are keywords which are entities.
!
! The values must be separated by two so we can add the direction to
! the entity for use as a case index.
!-

BIND
    END_ENTITY = UPLIT (0, 0),

    BW_ENT = UPLIT (
    	END_ENTITY - ADDR_BASE + V_FIELD * (ENT_K_BW) + L_FIELD * (2), CH$PTR (UPLIT ('BW'))),
    BR_ENT = UPLIT (
    	BW_ENT - ADDR_BASE + V_FIELD * (ENT_K_BR) + L_FIELD * (2), CH$PTR (UPLIT ('BR'))),
    BL_ENT = UPLIT (
    	BR_ENT - ADDR_BASE + V_FIELD * (ENT_K_BL) + L_FIELD * (2), CH$PTR (UPLIT ('BL'))),
    BPAR_ENT = UPLIT (
    	BL_ENT - ADDR_BASE + V_FIELD * (ENT_K_BPAR) + L_FIELD * (4), CH$PTR (UPLIT ('BPAR'))),
    BSEN_ENT = UPLIT (
    	BPAR_ENT - ADDR_BASE + V_FIELD * (ENT_K_BSEN) + L_FIELD * (4), CH$PTR (UPLIT ('BSEN'))),
    B_ENTS = UPLIT (
    	BSEN_ENT - ADDR_BASE + V_FIELD * (ENT_K_BPAGE) + L_FIELD * (5), CH$PTR (UPLIT ('BPAGE'))),
    C_ENTS = UPLIT (
    	END_ENTITY - ADDR_BASE + V_FIELD * (ENT_K_CHAR) + L_FIELD * (1), CH$PTR (UPLIT ('C'))),
    EW_ENT = UPLIT (
        END_ENTITY - ADDR_BASE + V_FIELD * (ENT_K_EW) + L_FIELD * (2), CH$PTR (UPLIT ('EW'))),
    EL_ENT = UPLIT (
    	EW_ENT - ADDR_BASE + V_FIELD * (ENT_K_EL) + L_FIELD * (2), CH$PTR (UPLIT ('EL'))),
    ER_ENT = UPLIT (
    	EL_ENT - ADDR_BASE + V_FIELD * (ENT_K_ER) + L_FIELD * (2), CH$PTR (UPLIT ('ER'))),
    EPAR_ENT = UPLIT (
    	ER_ENT - ADDR_BASE + V_FIELD * (ENT_K_EPAR) + L_FIELD * (4), CH$PTR (UPLIT ('EPAR'))),
    ESEN_ENT = UPLIT (
    	EPAR_ENT - ADDR_BASE + V_FIELD * (ENT_K_ESEN) + L_FIELD * (4), CH$PTR (UPLIT ('ESEN'))),
    E_ENTS = UPLIT (
        ESEN_ENT - ADDR_BASE + V_FIELD * (ENT_K_EPAGE) + L_FIELD * (5), CH$PTR (UPLIT ('EPAGE'))),
    L_ENTS = UPLIT (
    	END_ENTITY - ADDR_BASE + V_FIELD * (ENT_K_LINE) + L_FIELD * (1), CH$PTR (UPLIT ('L'))),
    N_ENTS = UPLIT (
    	END_ENTITY - ADDR_BASE + V_FIELD * (ENT_K_NL) + L_FIELD * (2), CH$PTR (UPLIT ('NL'))),
    PAR_ENT = UPLIT (
    	END_ENTITY - ADDR_BASE + V_FIELD * (ENT_K_PAR) + L_FIELD * (3), CH$PTR (UPLIT ('PAR'))),
    P_ENTS = UPLIT (
    	PAR_ENT - ADDR_BASE + V_FIELD * (ENT_K_PAGE) + L_FIELD * (4), CH$PTR (UPLIT ('PAGE'))),
    SR_ENT = UPLIT (
    	END_ENTITY - ADDR_BASE + V_FIELD * (ENT_K_SR) + L_FIELD * (2), CH$PTR (UPLIT ('SR'))),
    S_ENTS = UPLIT (
    	SR_ENT - ADDR_BASE + V_FIELD * (ENT_K_SEN) + L_FIELD * (3), CH$PTR (UPLIT ('SEN'))),
    V_ENTS = UPLIT (
    	END_ENTITY - ADDR_BASE + V_FIELD * (ENT_K_VERT) + L_FIELD * (1), CH$PTR (UPLIT ('V'))),
    W_ENTS = UPLIT (
    	END_ENTITY - ADDR_BASE + V_FIELD * (ENT_K_WORD) + L_FIELD * (1), CH$PTR (UPLIT ('W')));

BIND
    ENTITY_TABLE = UPLIT (
	B_ENTS - ADDR_BASE,
	C_ENTS - ADDR_BASE,
	END_ENTITY - ADDR_BASE,
	E_ENTS - ADDR_BASE,
	END_ENTITY - ADDR_BASE,
	END_ENTITY - ADDR_BASE,
	END_ENTITY - ADDR_BASE,
	END_ENTITY - ADDR_BASE,
	END_ENTITY - ADDR_BASE,
	END_ENTITY - ADDR_BASE,
	L_ENTS - ADDR_BASE,
	END_ENTITY - ADDR_BASE,
	N_ENTS - ADDR_BASE,
	END_ENTITY - ADDR_BASE,
	P_ENTS - ADDR_BASE,
	END_ENTITY - ADDR_BASE,
	END_ENTITY - ADDR_BASE,
	S_ENTS - ADDR_BASE,
	END_ENTITY - ADDR_BASE,
	END_ENTITY - ADDR_BASE,
	V_ENTS - ADDR_BASE,
	W_ENTS - ADDR_BASE);
!
! EXTERNAL REFERENCES:
!
!	In the routine
%SBTTL 'EDT$$KEY_WORD  - look for a key word'

GLOBAL ROUTINE EDT$$KEY_WORD (			! Look for a key word
    TABLE_NO, 					! 1 = verb table, 2 = entity table
    KEY_NUM					! Key number
    ) : NOVALUE =

!++
! FUNCTIONAL DESCRIPTION:
!
!	This routine scans a table of keywords, attempting to find a match
!	in the current command buffer pointed to by CMD_PTR .
!	The comparison is case blind.
!
! FORMAL PARAMETERS:
!
!  TABLE_NO		The number of the keyword table to use.  1 = use the
!			verb table, 2 = use the entity table.
!
!  KEY_NUM		The returned value for the number of the entity or
!			verb which matched from the table.  Zero indicates
!			no match.
!
!
! IMPLICIT INPUTS:
!
!	CMD_END
!	CMD_PTR
!
! IMPLICIT OUTPUTS:
!
!	CMD_PTR
!
! ROUTINE VALUE:
!
!	NONE
!
! SIDE EFFECTS:
!
!	NONE
!
!--

    BEGIN

    EXTERNAL
	CHAR_INFO : BLOCKVECTOR [256, 1],	!Information about each character
	CMD_END,				! End of command pointer
	CMD_PTR;				! Command string pointer

    LOCAL
	KW_POINTER,
	FIRST_CHAR,
	TABLE_OFFSET,
	FOUND,
	TABLE,
	TABLE_PTR : REF BLOCK [ ] FIELD (KEY_WORD_FIELD),
	C_POINTER;

    .KEY_NUM = 0;
    C_POINTER = .CMD_PTR;
    FIRST_CHAR = CH$RCHAR_A (C_POINTER);

    IF .CHAR_INFO [.FIRST_CHAR, CI_LC] THEN FIRST_CHAR = .FIRST_CHAR - %C'a' + %C'A';

    CASE .TABLE_NO FROM 1 TO 2 OF
	SET

	[1] :
	    BEGIN

	    IF ((.FIRST_CHAR LSS %C'A') OR (.FIRST_CHAR GTR %C'^')) THEN RETURN;

	    TABLE = VERB_TABLE;
	    TABLE_OFFSET = (.FIRST_CHAR - %C'A');
	    TABLE_PTR = .(.TABLE + .TABLE_OFFSET) + ADDR_BASE;
	    END;

	[2] :
	    BEGIN

	    IF ((.FIRST_CHAR LSS %C'B') OR (.FIRST_CHAR GTR %C'W')) THEN RETURN;

	    TABLE = ENTITY_TABLE;
	    TABLE_OFFSET = (.FIRST_CHAR - %C'B');
	    TABLE_PTR = .(.TABLE + .TABLE_OFFSET) + ADDR_BASE;
	    END;

	[OUTRANGE] :
	    ASSERT (0);
	TES;

    WHILE (.TABLE_PTR [KEY_WORD_LEN] NEQ 0) DO
	BEGIN
	KW_POINTER = .TABLE_PTR [KEY_WORD_POINTER];
	C_POINTER = .CMD_PTR;
	FOUND = 1;

	IF CH$PTR_LEQ (CH$PLUS (.C_POINTER, .TABLE_PTR [KEY_WORD_LEN]), .CMD_END)
	THEN
	    BEGIN

	    INCR I FROM 1 TO .TABLE_PTR [KEY_WORD_LEN] DO
		BEGIN

		LOCAL
		    CHAR;

		CHAR = CH$RCHAR_A (C_POINTER);

		IF .CHAR_INFO [.CHAR, CI_LC] THEN CHAR = .CHAR - %C'a' + %C'A';

		IF (.CHAR NEQ CH$RCHAR_A (KW_POINTER)) THEN FOUND = 0;

		END;

	    IF .FOUND
	    THEN
		BEGIN
		.KEY_NUM = .TABLE_PTR [KEY_WORD_NUM];

!+
! Skip over the keyword.
!-
		CMD_PTR = CH$PLUS (.CMD_PTR, .TABLE_PTR [KEY_WORD_LEN]);
		RETURN;
		END;
	    END;
	TABLE_PTR = .TABLE_PTR [KEY_WORD_NEXT] + ADDR_BASE;
	END;
    RETURN;
    END;

END
ELUDOM