DESCRIPTION:                                                       
 THE PROCEDURE ARRAYDEC IS THE INTERFACE BETWEEN THE COMPILERS AND THE MCP
 FOR THE HANDLING OF ARRAY  DECLARATIONS  WITHIN A PROCEDURE  BLOCK. 
 THERE ARE A FEW  INTERESTING THINGS  ABOUT THIS PROCEDURE WHICH ARE
 EXPLAINED IN SOMEWHAT OF A DETAIL .  
 ANYONE WANTING TO UNDERSTAND THIS PROCEDURE MUST LEAVE THE GASTRIC
 LINING OF THEIR STOMACHS HOME,FOR THIS PROCEDURE IS KNOWN TO HAVE CAUSED
 ULCERS AMONGST LESSER MORTALS.           
                                                               
 FIRSTLY, THE COMPILER GENERATES A CALL TO ARRAYDEC WHENEVER IT COMES ACROSS
 AN ARRAY DECLARATION THAT IS NOT A SIMPLE, SMALL, ONE-DIMENSIONAL ARRAY. 
 A FEW EXAMPLES ARE LONG ARRAYS, EITHER DECLARED LONG OR ASSUMED TO BE PAGED
 EVENT ARRAYS, MULTI-DIMENSIONED ARRAYS, OWN ARRAYS ETC.                     
                                                               
 THERE ARE THREE PARAMETERS THAT ARE PASSED TO ARRAYDEC. THEY ARE
 1. SIRW TO MOM, 
 2. NUMBER OF DIMENSIONS AND 
 3. INFORMATION ABOUT THE TYPE OF ARRAY BEING DECLARED.                       
                                                               
 OTHER THAN THESE PARAMETERS, FOR MULTI-DIMENSIONAL ARRAYS AND EVEN SINGLE
 DIMENSIONAL OWN ARRAYS SOME ADDITIONAL PARAMETERS ARE PASSED BELOW THE
 MSCW OF ARRAYDEC. THESE ARE THE SIZES OF EACH DIMENSION AND IN CASE OF OWN
 ARRAYS ALSO THE LOWER BOUNDS. WHEREAS IT IS NOT QUITE CLEAR WHY WE NEED TO
 PASS THE LOWER BOUNDS FOR EACH DIMENSION OF THE OWN ARRAY DECLARED,    
 LITTLE THOUGHT WILL SHOW THAT THE SIZE FOR EACH DIMENSION MUST BE PASSED
 AND THAT THERE IS NO OTHER WAY OF PASSING THIS INFORMATION TO ARRAYDEC. 
 AT THIS POINT, JUST BEAR IN MIND THAT WE NEED TO CUT THE STACK BACK WHEN WE
 EXIT FROM ARRAYDEC SO THAT THESE FUNNY PARAMETERS ARE WIPED OUT FROM THE
 STACK.     
                                                               
 FOR THE (SUB/SUPRA/AB)NORMAL SINGLE DIMENSIONAL ARRAYS, E.G.LONG, EVENT, 
 EBCDIC ETC., ARRAYDEC MERELY CREATES A CORRECT ABSENT, UNTOUCHED DESCRIPTOR
 AND PLACES IT AT THE LOCATION TO WHICH THE SIRW POINTS.                                        
                                                               
 IN CASE OF MULTI DIMENSIONAL ARRAYS, THE SIZE OF DIMENSIONS HIGHER THAN ONE
 IS PLACED IN A STRUCTURE CALLED THE AIT -THE ARRAY INFORMATION TABLE.
 AFTER EXIT FROM ARRAYDEC, THE LOCATION IN STACK TO WHICH THE SIRW POINTS,
 WILL CONTAIN AN ABSENT, UNTOUCHED MOM. THE ASDINDEX OF THIS DESCRIPTOR WILL   
 HAVE THE INDEX INTO THE AIT WHERE THE DESCRIPTOR TO THE NEXT DIMENSION WILL
 HAVE BEEN CREATED, ALBEIT WITH A ZERO TAG. HIS DESCRIPTOR WILL HAVE ANOTHER
 INDEX INTO THE AIT FOR THE DESCRIPTOR TO THE NEXT DIMENSION, IF ANY.
 FOR FURTHER DETAIL ON AIT/OAT STRUCTURES LOOK AT THE DESCRIPTION IN THE
 PROCEDURE AITINSERT. A POINT OF INTEREST HERE IS THAT THE TOUCH INTERRUPT       
 MUST TAKE THE AITINDEX FROM THE UNTOUCHED MOM AND PLACE IT IN 
 ASD_ADDRESS SO THAT PRESENCEBIT CAN GET THIS INFORMATION.     
                                                               
 IN CASE OF OWN ARRAYS, THE COMPILER GENERATES CODE TO PLACE THE MOM IN THE
 MOST GLOBAL ENVIRONMENT OF THE DECLARING BLOCK.THE DATA STRUCTURE CREATED 
 TO DEAL WITH OWN ARRAYS IS CALLED THE OAT - THE OWN ARRAY TABLE. IT IS 
 IDENTICAL IN STRUCTURE TO THE AIT. THE OAT IS ALSO CREATED IN THE SAME
 MANNER AS THE THE AIT EXCEPT FOR THE FACT THAT ALL OWN ARRAYS, SINGLE AND   
 MULTI DIMENSIONAL HAVE ENTRIES IN THE OAT. WE ALSO SAVE THE LOWER BOUNDS OF
 EACH DIMENSION IN THE OAT. THE REASONS FOR DOING THIS ARE NOT CLEAR AND AS
 SUCH THEY CONSTITUTE IN PART THE MORE NEBULOUS ASPECTS OF THIS PROCEDURE. 
 ANOTHER UNKNOWN QUANTITY IS THE REASON WHY THERE IS CODE IN ARRAYDEC THAT     
 LOOKS IF THE MOM HAS BEEN ENTERED IN THE OAT. IF ARRAYDEC IS BYPASSED ON
 THE COMPILER FINDING AN ODD TAG WORD THEN ARRAYDEC IS NEVER GOING TO BE
 CALLED TWICE FOR THE SAME ARRAY. OR IS IT?       
                                                               
 IN CASE OF STRING ARRAYS, ARRAYDEC USES THREE STACK CELLS ON THE DECLARING
 STACK. THE FIRST CELL CARRIES A TAG 4 WORD, THE SECOND IS THE DESCRIPTOR TO
 THE DOPEVECTOR, EACH ELEMENT OF WHICH IS A STRING, AND THE THIRD CELL IS A
 DESCRIPTOR TO AN ARRAY EACH ELEMENT OF WHICH CONTAINS THE ACTUAL LENGTH OF
 THE CORRESPONDING STRING ELEMENT. THE MULTI DIMENSIONAL STRING ARRAYS ARE
 MERELY EXTENSION OF THIS CONCEPT IN MORE DIMENSIONS.      
                                                               
 THIS PARAGRAPH DESCRIBES HOW WE EXIT FROM ARRAYDEC. AFTER ARRAYDEC IS
 FINISHED WITH CREATING THE VIRGIN MOM, IT MUST REMOVE THE FUNNY PARAMETERS
 UNDER IT'S MSCW. THIS CAN BE DONE EITHER BY THE COMPILER (WHICH IT IS NOT)
 OR BY THE MCP (THE WAY IT IS). ARRAYDEC KNOWS WHERE IN THE STACK THE FUNNY
 STUFF BEGINS. ALL IT NEEDS TO DO IS,TO MOVE IT'S MSCW (D1MSCW) AND THE
 RCW (D1RCW) TO THIS PLACE IN STACK AND CHANGE D[1] REGISTER TO POINT TO 
 THIS STACK CELL. ALL THE FUNNY STUFF IS ATOMIZED IN AN INSTANT, WHEN
 ARRAYDEC EXITS.                           
                                                               
 For structure type variables, entries are added at the end of the block to
 describe descending dimensions of multi-dimension arrays, and the length 
 of extended arrays.  A word is also added for DCALGOL queues to mark the 
 fact that the queue may need disposal.  This word contains two fields, 
 STV_Q_COUNTF, which is the number of queues (or queue arrays) declared in   
 one declaration, and STV_Q_LINKF which is the offset in the block of the 
 last one declared.                               
                                                               
 Words added at the end of the structure are managed by STV_TOP which 
 contains two pointers:  STV_NEXTF and STV_Q_LINKF.STV_NEXTF manages 
 allocation of additional words.  It always points to the next usable word.
 STV_Q_LINKF points to the end of the chain of DCALGOL queue items with 
 zero as the end of list value.                                                   
                                                               
 PARAMETERS:                                                        
 1. SIRW_TO_MOM :                                              
       THE COMPILER GENERATES A SIRW TO THE STACKCELL WHERE THE
       MOM WILL RESIDE WHEN ARRAYDEC GETS DONE.                
 2. NO_OF_DIMS :                                               
       THIS IS THE NUMBER OF DIMENSIONS OF THE ARRAY THAT IS   
       BEING DECLARED. IT IS USED TO REACH UNDER THE STACK.    
 3. TYPE_INFO :                                                
       INFORMATION ABOUT THE ARRAY BEING DECLARED. THE FIELDS  
       ARE DECLARED IN THE DEFINE BELOW.                       
                                                               
 RESULTS:                                                           
 AN UNTOUCHED, ABSENT MOM WILL BE PLACED IN THE STACK CELL POINTED TO BY THE
 SIRW. THIS MAY OR MAY NOT HAVE AN INDEX INTO THE AIT/OAT.                                             
                                                               
 ASSUMPTIONS:                                                       
 IT IS VERY IMPORTANT TO RECOGNIZE THAT THIS PROCEDURE WORKS VERY CLOSELY
 WITH THE COMPILERS. IF THE COMPILERS DO NOT GENERATE CODE TO PASS THE
 PARAMETERS TO ARRAYDEC CORRECTLY, SATISFACTION MAY NOT BE GUARANTEED.                           
                                                               
 SIDE EFFECTS:                                                      
                                                               
 LOCKS:                                                             
 OATLOCK