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 DESCRIPTORnAND PLACES IT AT THE LOCATION TO 
WHICH THE SIRW POINTS.                                        
                                                               
IN CASE OF MULTI DIMENSIONAL ARRAYS, THE SIZE OF DIMENSIONS 
HIGHER THAN ONEnIS 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