! EVE$SYNONYMS.TPU 		31-DEC-1992 12:14			Page 1

module eve$synonyms ident "V03-003"

!
!	       COPYRIGHT © 1987,1992 BY
!	DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASSACHUSETTS
!		    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:
!	DECTPU - Text Processing Utility
!	EVE - Extensible Versatile Editor
!
! ABSTRACT:
!	This is the source program for the EVE interface synonym creation.
!
! ENVIRONMENT:
!	OpenVMS VAX, OpenVMS AXP, RISC/ULTRIX
!
!Author: Bill Robinson
!
! CREATION DATE: 5-Jun-1987
!
! MODIFIED BY:
!
!--

! EVE$SYNONYMS.TPU 							Page 2

!++
!				Table of Contents 
!
!			        EVE$SYNONYMS.TPU
!				31-DEC-1992 12:14
!
!	Procedure name			Page	Description
!	--------------			----	------------
!
!	eve$$init_all_synonyms 		   3	Build hook for initing synonyms
!	eve$make_synonym_a_terminator 	   4	Make a synonym a terminator
!	eve$$use_language 		   5	declares a language for key caps
!	eve$$define_key_language 	   6	declares a language for key caps
!	eve$$define_key_translation 	   7	between TPU's name and key cap
!	eve$$define_key_modifiers 	   8	synonyms for TPU keywords
!	eve$$add_table_entry 		   9	to key/engraving xlation string
!	eve$$add_key_synonyms 		  10	to specified string table
!--

! EVE$SYNONYMS.TPU 							Page 3

procedure eve$$init_all_synonyms	! Build hook for initing synonyms

! This procedure is overwritten by EVE$BUILD.  EVE$BUILD executes any
! <FACILITY>_DECLARE_SYNONYM procedures, and tests if each created command
! argument variable declarations (via calls to EVE$BUILD_SYNONYM); if so,
! the declarations are put into <FACILITY>_SYNONYM_INIT procedures,
! plus code that builds the corresponding elements of the eve$$x_synonym_array.
! This procedure is overwritten with calls to those <FACILITY>_SYNONYM_INIT
! procedures,

endprocedure;	! eve$$init_all_synonyms

! EVE$SYNONYMS.TPU 							Page 4

procedure eve$make_synonym_a_terminator ! Make a synonym a terminator
    (eve_command, the_synonym);


! eve$make_synonym_a_terminator ! Make a synonym a terminator
!
! Description
!    If eve_command is a terminator, and if the_synonym is not already
!    in the terminator-key data structure associated with eve_command,
!    then add the_synonyn to that structure.

local   array_size

on_error
    [OTHERWISE]:
endon_error;

if the_synonym = ""
then
    return (FALSE);
endif;
array_size := eve$$x_terminator_array {0};
loop
    exitif array_size < 1;
    if index (" " + eve$$x_terminator_array {array_size} + " ",
	      " " + eve_command + " ") > 0
    then			! found eve_command in a terminator
	if index (" " + eve$$x_terminator_array {array_size} + " ",
		  " " + the_synonym + " ") = 0
	then			! the_synonym is not that terminator yet
	    eve$$x_terminator_array {array_size} :=
						    eve$$x_terminator_array
						    {array_size} + " "
						    + the_synonym;
	endif;
    endif;
    array_size := array_size - 1;
endloop;

return (TRUE);

endprocedure;		! eve$make_synonym_a_terminator

! EVE$SYNONYMS.TPU 							Page 5

procedure eve$$use_language ! declares a language for key caps

! Call this routine during startup and to define the language and when
! you want to change the local language translations of the key cap
! engravings.

    (language_id);	! Plain text identifer of a language to be defined

local   edited_id,	! copy of language_id
	a_key_map;	! tentative copy of key translations keymap

if get_info (language_id, 'type') <> STRING
then
    eve$message (EVE$_BADLANGIDTYPE, 0, "EVE$$USE_LANGUAGE");
    return FALSE;
endif;
edited_id := edit (language_id, TRIM, UPPER);

a_key_map := eve$kt_key_language_prefix + edited_id;
if not eve$key_map_exists (a_key_map)
then
    eve$message (EVE$_BADLANGID, 0, edited_id);
    return FALSE;
endif;
eve$x_current_language_keymap := a_key_map;

return TRUE;

endprocedure; 	 ! eve$$use_language

! EVE$SYNONYMS.TPU 							Page 6

procedure eve$$define_key_language ! declares a language for key caps

! Call this routine before you declare a set of key engravings for a
! local language.  This routine does the book keeping needed to make EVE
! aware of the language you intend to declare.

    (language_id);	! Plain text identifer of a language to be defined

local   edited_id,	! copy of language_id
	a_key_map,	! tentative copy of key translations keymap
	saved_informational;

on_error
    [OTHERWISE]:
	set (INFORMATIONAL, saved_informational);
endon_error;

saved_informational := get_info (SYSTEM, "informational");
eve$x_null_program := (eve$kt_null_program);

if get_info (language_id, 'type') <> STRING
then
    eve$message (EVE$_BADLANGIDTYPE, 0, "EVE$$DEFINE_KEY_LANGUAGE");
    return FALSE;
endif;
edited_id := edit (language_id, TRIM, UPPER);

! Create a key map for the language and initialize it's translation strings

a_key_map := eve$kt_key_language_prefix + edited_id;
if not eve$key_map_exists (a_key_map)
then
    eve$x_current_language_keymap := create_key_map (a_key_map);
else
    eve$x_current_language_keymap := a_key_map;
endif;

set (INFORMATIONAL, OFF);
define_key (eve$x_null_program, key_name (eve$kt_xlations_ver_key),
	    eve$kt_xlations_version, eve$x_current_language_keymap);
define_key (eve$x_null_program, key_name (eve$kt_key_xlations_key),
	    eve$kt_key_string_delimiter, eve$x_current_language_keymap);
define_key (eve$x_null_program, key_name (eve$kt_modif_xlations_key),
	    eve$kt_key_string_delimiter, eve$x_current_language_keymap);
set (INFORMATIONAL, saved_informational);
return TRUE;

endprocedure ! eve$$define_key_language

! EVE$SYNONYMS.TPU 							Page 7

procedure eve$$define_key_translation ! between TPU's name and key cap

    (language_id, 	! The language this is being defined for
     tpu_keyname,	! The valid key name (unmodified)
     synonym_1;		! The primary translation, to be used by EVE
			!    This will be the one EVE uses when describing
			!    the key.

     synonym_2,		! A series of secondary translations, all of
     synonym_3,		!    which EVE will accept as valid key names
     synonym_4,         !    ...
     synonym_5,
     synonym_6);

local   edited_synonym, ! local copy of primary translation
	edited_id,	! local copy of language id
	a_key_map,	! tentative copy of key translations keymap
	translations,	! temporary copy of translation lookup string
	saved_informational;

on_error
    [OTHERWISE]:
	set (INFORMATIONAL, saved_informational);
endon_error;

saved_informational := get_info (SYSTEM, "informational");

! verify the id and use it to fetch the translation string

if get_info (language_id, 'type') <> STRING
then
    eve$message (EVE$_BADLANGIDTYPE, 0, "EVE$$DEFINE_KEY_TRANSLATION");
    return FALSE;
endif;
edited_id := edit (language_id, TRIM, UPPER);
a_key_map := eve$kt_key_language_prefix + edited_id;
if not eve$key_map_exists (a_key_map)
then
    eve$message (EVE$_BADLANGID, 0, edited_id);
    return FALSE;
endif;
eve$x_current_language_keymap := a_key_map;
translations := lookup_key (key_name (eve$kt_key_xlations_key), COMMENT,
			    eve$x_current_language_keymap);

! Add all strings, primary and secondary, to the string-to-keyname translation
! table

if not eve$$add_table_entry (translations, tpu_keyname,
			     synonym_1, synonym_2,
			     synonym_3, synonym_4,
			     synonym_5, synonym_6)
then
    return FALSE;
endif;

! Now add the primary string to the keymap for key to string translations

edited_synonym := edit (synonym_1, TRIM);
set (INFORMATIONAL, OFF);
define_key (eve$x_null_program, tpu_keyname,
	    edited_synonym, eve$x_current_language_keymap);
define_key (eve$x_null_program,
	    key_name (eve$kt_key_xlations_key),
	    translations,
	    eve$x_current_language_keymap);
set (INFORMATIONAL, saved_informational);
return TRUE;

endprocedure ! eve$$define_key_translation

! EVE$SYNONYMS.TPU 							Page 8

procedure eve$$define_key_modifiers ! synonyms for TPU keywords

    (language_id, 	! the language this is being defined for
     tpu_keyname,	! the valid tpu modifier key word
     synonym_1;	! The primary translation, to be used by EVE
		!    This will be the one EVE uses when describing
		!    the modifier.

     synonym_2,	! A series of secondary translations, all of
     synonym_3,	!    which EVE will accept as valid key names
     synonym_4,
     synonym_5,
     synonym_6);

local   edited_synonym, ! local copy of primary translation
	edited_id,	! local copy of language id
	a_key_map,	! tentative copy of key translations keymap
	modifiers,	! temporary copy of modifier lookup string
	saved_informational;

on_error
    [OTHERWISE]:
	set (INFORMATIONAL, saved_informational);
endon_error;

saved_informational := get_info (SYSTEM, "informational");

! verify the id and use it to fetch the translation string

if get_info (language_id, 'type') <> STRING
then
    eve$message (EVE$_BADLANGIDTYPE, 0, "EVE$$DEFINE_KEY_MODIFIERS");
    return FALSE;
endif;
edited_id := edit (language_id, TRIM, UPPER);

a_key_map := eve$kt_key_language_prefix + edited_id;
if not eve$key_map_exists (a_key_map)
then
    eve$message (EVE$_BADLANGID, 0, edited_id);
    return FALSE;
endif;
eve$x_current_language_keymap := a_key_map;
modifiers := lookup_key (key_name (eve$kt_modif_xlations_key), COMMENT,
			 eve$x_current_language_keymap);
edited_synonym := edit (synonym_1, TRIM);
set (INFORMATIONAL, OFF);
case tpu_keyname
    [SHIFT_KEY]:
	define_key (eve$x_null_program, key_name (eve$k_shift_key_key),
		    edited_synonym, eve$x_current_language_keymap);
    [FUNCTION]:
	define_key (eve$x_null_program, key_name (eve$k_function_key),
		    edited_synonym, eve$x_current_language_keymap);
    [KEYPAD]:
	define_key (eve$x_null_program, key_name (eve$k_keypad_key),
		    edited_synonym, eve$x_current_language_keymap);
    [SHIFT_MODIFIED]:
	define_key (eve$x_null_program, key_name (eve$k_shift_modified_key),
		    edited_synonym, eve$x_current_language_keymap);
    [CTRL_MODIFIED]:
	define_key (eve$x_null_program, key_name (eve$k_ctrl_modified_key),
		    edited_synonym, eve$x_current_language_keymap);
    [HELP_MODIFIED]:
	define_key (eve$x_null_program, key_name (eve$k_help_modified_key),
		    edited_synonym, eve$x_current_language_keymap);
    [ALT_MODIFIED]:
	define_key (eve$x_null_program, key_name (eve$k_alt_modified_key),
		    edited_synonym, eve$x_current_language_keymap);
    [OTHERWISE]:
	eve$message (EVE$_BADMODIFIER);
	return FALSE;
endcase;

! Add all strings, primary and secondary, to the string-to-modifier translation
! table

if not eve$$add_table_entry (modifiers, tpu_keyname,
			     synonym_1, synonym_2,
			     synonym_3, synonym_4,
			     synonym_5, synonym_6)
then
    return FALSE;
endif;

define_key (eve$x_null_program, key_name (eve$kt_modif_xlations_key), modifiers,
	    eve$x_current_language_keymap);
set (INFORMATIONAL, saved_informational);
return TRUE;
endprocedure ! eve$$define_key_modifiers

! EVE$SYNONYMS.TPU 							Page 9

procedure eve$$add_table_entry 	! to key/engraving xlation string

    (translation_table,	! a string which contains a lookup table of xlations
     tpu_key_name, 	! a TPU keyname
     synonym_1;	! the primary translation, to be used by EVE
     synonym_2,	! a series of secondary translations, all of
     synonym_3,	!    which EVE will accept as valid key names
     synonym_4,
     synonym_5,
     synonym_6);

local   xlated_keyname,		! String version of std TPU keyname
	edited_engraving;	! Edited version of engraving parameter

if get_info (synonym_1, 'type') = STRING
then
    !
    ! We have an engraving to validate
    !
    if get_info (tpu_key_name, 'type') <> KEYWORD
    then
	eve$message (EVE$_BADARGUMENT, 0,
		     str (get_info (tpu_key_name, "type")), str (KEYWORD));
	return FALSE;
    endif;
    if eve$$add_key_synonyms (translation_table, tpu_key_name,
			      synonym_1, synonym_2,
			      synonym_3, synonym_4,
			      synonym_5, synonym_6)
    then
	xlated_keyname := str (tpu_key_name);
	! Add keyname string to end of our entry in string table

	translation_table := translation_table + eve$kt_key_name_delimiter
			     + xlated_keyname + eve$kt_key_string_delimiter;
    else
	return FALSE;
    endif;
endif;
return TRUE;

endprocedure;		! eve$$add_table_entry

! EVE$SYNONYMS.TPU 							Page 10

procedure eve$$add_key_synonyms ! to specified string table

    (translation_table,	! a string which contains a lookup table of xlations
     tpu_key_name,	! key for which synonyms are being added
     synonym_1;	! the primary translation, to be used by EVE
     synonym_2,	! a series of secondary translations, all of
     synonym_3,	!    which EVE will accept as valid key names
     synonym_4,
     synonym_5,
     synonym_6);

local   xlated_keyname,		! String version of std TPU keyname
	edited_synonym_1;	! Edited version of synonym_1 parameter

if get_info (synonym_1, 'type') <> UNSPECIFIED
then
    ! We have an engraving to verify.  Note that an unspecified parameter
    ! is perfectly valid, and results in a no-op

    ! Validate our input

    if get_info (synonym_1, 'type') <> STRING
    then
	eve$message (EVE$_BADARGUMENT, 0,
		     str (get_info (synonym_1, "type")), str (STRING));
	return FALSE;
    endif;
    edited_synonym_1 := edit (synonym_1, TRIM);
    if index (edited_synonym_1, eve$kt_key_string_delimiter) > 0
    then
	eve$message (EVE$_BADKEYSYNONYM, 0, synonym_1);
	return FALSE;
    endif;
    if index (edited_synonym_1, eve$kt_key_name_delimiter) > 0
    then
	eve$message (EVE$_BADKEYSYNONYM, 0, synonym_1);
	return FALSE;
    endif;
    if index (translation_table, eve$kt_key_string_delimiter +
	      edited_synonym_1 + eve$kt_key_string_delimiter) > 0
    then
	eve$message (EVE$_DUPLSYNONYM, 0,
		     edited_synonym_1, get_info (tpu_key_name, "name"));
	return FALSE;
    endif;

    ! Parameters are valid, add a synonym string to our string table

    translation_table := translation_table
			 + edited_synonym_1 + eve$kt_key_string_delimiter;
    ! recurseively call ourselves to add the
    ! rest of the parameters
    return eve$$add_key_synonyms (translation_table, tpu_key_name,
				  synonym_2,
				  synonym_3, synonym_4,
				  synonym_5, synonym_6)
endif;

return TRUE;

endprocedure;		! eve$$add_key_synonyms

! EVE$SYNONYMS.TPU 							Page 11

! Module initialization code

local   array_size,
	temp,
	the_key;

! create the string-indexed array for all synonyms

if get_info (eve$$x_synonym_array, "type") <> ARRAY
then
    eve$$x_synonym_array := create_array ();
endif;

eve$$init_all_synonyms;		! declare all facility synonyms

endmodule;


! EVE$SYNONYMS.TPU 							Page 12

! The following two statements are executed here at build time so that
! DO keys can be defined during the build.  The do key array processing
! (eve$$add_do_key, etc) requires a user level name, and thus the GOLD
! modifier must be available.

eve$$define_key_language ('English');
eve$$define_key_modifiers ('English', SHIFT_KEY, 'GOLD');