Google
 

Trailing-Edge - PDP-10 Archives - -
There are no other files named in the archive.
(FILECREATED " 2-DEC-78 20:58:11" <LAASER>DICTIONARY.;32 22420  

     changes to:  ADDTODICTIONARY1 ADDTODICTIONARY DICTIONARYCOMS DICTIONARYBLOCKS CREATEDICTIONARY 
CREATEDICTIONARY1 FINDINDICTIONARY GETTOPENTRY LISTDICTIONARY NUMOFENTRIES

     previous date: " 2-DEC-78 20:53:30" <LAASER>DICTIONARY.;31)


(PRETTYCOMPRINT DICTIONARYCOMS)

(RPAQQ DICTIONARYCOMS ((FNS * DICTIONARYFNS)
		       (RECORDS * DICTIONARYRECORDS)
		       (VARS * DICTIONARYVARS)
		       (BLOCKS * DICTIONARYBLOCKS)))

(RPAQQ DICTIONARYFNS (ADDTODICTIONARY ADDTODICTIONARY1 COPYANDRAISE COPYSTRING CREATEDICTIONARY 
				      CREATEDICTIONARY1 FINDINDICTIONARY FREEDICTARRAY 
				      GETCOMPLETIONSTRING GETNEWDICTIONARYARRAY GETTOPENTRY 
				      LISTDICTIONARY LISTDICTIONARY1 NUMOFENTRIES 
				      SETUPEXCEPTIONALENTRIES))
(DEFINEQ

(ADDTODICTIONARY
  [LAMBDA (ENTRY DICT)                                      (* WTL: " 2-DEC-78 20:37")
    (PROG [(STRPTR (CONSTANT (MKSTRING)))
	   (NEWENTRYNAME (NOT (fetch (DICTIONARY ENTRY) of (FINDINDICTIONARY ENTRY DICT]
          (RETURN (if (NLISTP ENTRY)
		      then (ADDTODICTIONARY1 (COPYSTRING (U-CASE (MKSTRING ENTRY))
							 STRPTR)
					     T DICT)
		    else (ADDTODICTIONARY1 (COPYSTRING (U-CASE (MKSTRING (CAR ENTRY)))
						       STRPTR)
					   (CDR ENTRY)
					   DICT])

(ADDTODICTIONARY1
  [LAMBDA (ENTRYNAME ENTRYVALUE DICT)                       (* WTL: " 2-DEC-78 20:41")
    (if (NULL DICT)
	then (CREATEDICTIONARY (LIST (CONS (CONCAT ENTRYNAME)
					   ENTRYVALUE)))
      else
       (PROG ((STRPTR (CONSTANT (MKSTRING)))
	      COMMONCHARS STR)
	     (SETQ STR (COPYSTRING (GETCOMPLETIONSTRING DICT)
				   STRPTR))
	     (while (AND (NOT (ZEROP (NCHARS ENTRYNAME)))
			 (NOT (ZEROP (NCHARS STR)))
			 (EQ (NTHCHAR ENTRYNAME 1)
			     (NTHCHAR STR 1)))
		do (SETQ COMMONCHARS (CONS (GNC ENTRYNAME)
					   COMMONCHARS))
		   (GNC STR))
	     (if [AND (NOT (ZEROP (NCHARS ENTRYNAME)))
		      (NOT (ZEROP (NCHARS STR]
		 then [RETURN (create DICTIONARY2
				      COMMONSTRING _(MKSTRING (PACK (DREVERSE COMMONCHARS)))
				      NUMBEROFENTRIES _(ADD1 (NUMOFENTRIES DICT))
				      SUBDICTIONARIES _(LIST (CONS (GNC ENTRYNAME)
								   (create DICTIONARY0
									   COMMONSTRING _(CONCAT
									     ENTRYNAME)
									   ENTRY _ ENTRYVALUE))
							     (CONS (GNC STR)
								   (PROGN (replace (DICTIONARY 
										     COMMONSTRING)
									     of DICT with STR)
									  DICT]
	       elseif (NOT (ZEROP (NCHARS STR)))
		 then                                       (* HERE KNOW THAT WE HAVE A MORE FOR THE COMMON STRING 
							    IN STR2, BUT WE'VE RUN OUT OF CHARS IN THE NEW ENTRY)
		      [RETURN (create DICTIONARY2
				      ENTRY _ ENTRYVALUE
				      NUMBEROFENTRIES _(ADD1 (fetch (DICTIONARY NUMBEROFENTRIES)
								of DICT))
				      SUBDICTIONARIES _(LIST (CONS (GNC STR)
								   (PROGN (replace (DICTIONARY 
										     COMMONSTRING)
									     of DICT with STR)
									  DICT]
	       else                                         (* BY NOW WE KNOW THAT THERE ARE NO MORE EVERYTHING IN 
							    THE ORIGINAL COMMONSTRING WAS ALSO FOUND IN THE NEW 
							    ENTRY.)
		(RETURN
		  (if (NOT (ZEROP (NCHARS ENTRYNAME)))
		      then                                  (* WE WILL HAVE TO GO DEEPER IN THE DICTIONARY TO FIND 
							    OUT WHERE TO PUT THIS)
		       (SELECTQ
			 (fetch (DICTIONARY DICTIONARYTYPE)
				of DICT)
			 [DICTIONARY0                       (* HERE (NULL NEWENTRYNAME) IS EQUIVALENT TO ENTRYNAME 
							    BEING THE EMPTY STRING)
				      (create DICTIONARY2
					      COMMONSTRING _(fetch (DICTIONARY1 COMMONSTRING)
							       of DICT)
					      ENTRY _(fetch (DICTIONARY0 ENTRY) of DICT)
					      NUMBEROFENTRIES _ 2
					      SUBDICTIONARIES _(LIST (CONS (GNC ENTRYNAME)
									   (create DICTIONARY0
										   COMMONSTRING _(
										     CONCAT ENTRYNAME)
										   ENTRY _ ENTRYVALUE]
			 (DICTIONARY1                       (* WE WILL HAVE TO GO DEEPER IN THE DICTIONARY TO FIND 
							    OUT WHERE TO PUT THIS)
			   (PROG ((ARRAYENTRY (IDIFFERENCE (CHCON1 (GNC ENTRYNAME))
							   64)))
			         [if NEWENTRYNAME
				     then (replace (DICTIONARY1 NUMBEROFENTRIES) of DICT
					     with (ADD1 (fetch (DICTIONARY1 NUMBEROFENTRIES)
							   of DICT]
			         [if (OR (ILESSP ARRAYENTRY 1)
					 (IGREATERP ARRAYENTRY 64))
				     then [if (fetch (DICTIONARY1 EXCEPTIONALSUBDICTIONARIES)
						 of DICT)
					      then (PUTASSOC
						     (FCHARACTER (IPLUS ARRAYENTRY 64))
						     [ADDTODICTIONARY1
						       ENTRYNAME ENTRYVALUE
						       (CDR (FASSOC (FCHARACTER (IPLUS ARRAYENTRY 64))
								    (fetch (DICTIONARY1 
								       EXCEPTIONALSUBDICTIONARIES)
								       of DICT]
						     (fetch (DICTIONARY1 EXCEPTIONALSUBDICTIONARIES)
							of DICT))
					    else (replace (DICTIONARY1 EXCEPTIONALSUBDICTIONARIES)
						    of DICT
						    with (LIST (CONS (FCHARACTER (IPLUS ARRAYENTRY 64)
										 )
								     (CREATEDICTIONARY
								       (LIST (CONS ENTRYNAME 
										   ENTRYVALUE]
				   else (SETA (fetch (DICTIONARY1 SUBDICTIONARIES) of DICT)
					      ARRAYENTRY
					      (ADDTODICTIONARY1 ENTRYNAME ENTRYVALUE
								(ELT (fetch (DICTIONARY1 
										  SUBDICTIONARIES)
									of DICT)
								     ARRAYENTRY]
			         (RETURN DICT)))
			 (DICTIONARY2
			   (PROG ((FIRSTCHAR (GNC ENTRYNAME))
				  (COUNT 0)
				  ARRAYENTRY DICTARRAY EXCEPTIONS)
			         [if NEWENTRYNAME
				     then (replace (DICTIONARY2 NUMBEROFENTRIES) of DICT
					     with (ADD1 (fetch (DICTIONARY2 NUMBEROFENTRIES)
							   of DICT]
			         (PUTASSOC FIRSTCHAR [ADDTODICTIONARY1
					     ENTRYNAME ENTRYVALUE (CDR (FASSOC FIRSTCHAR
									       (fetch (DICTIONARY2
											
										  SUBDICTIONARIES)
										  of DICT]
					   (fetch (DICTIONARY2 SUBDICTIONARIES) of DICT))
			         [if (NOT (ILESSP (PROGN [for SUBDICT in (fetch (DICTIONARY2 
										  SUBDICTIONARIES)
									    of DICT)
							    do (SETQ ARRAYENTRY
								 (IDIFFERENCE (CHCON1 (CAR DICT))
									      64))
							       (if (NOT (OR (ILESSP ARRAYENTRY 1)
									    (ILESSP 26 ARRAYENTRY)))
								   then (SETQ COUNT (ADD1 COUNT]
							 COUNT)
						  MAXDICT2SIZE))
				     then (SETQ DICTARRAY (GETNEWDICTIONARYARRAY))
					  (for SUBDICT in (fetch (DICTIONARY2 SUBDICTIONARIES)
							     of DICT)
					     do (SETQ ARRAYENTRY (IDIFFERENCE (CHCON1 (CAR SUBDICT))
									      64))
						(if (AND (ILESSP ARRAYENTRY 1)
							 (ILESSP 26 ARRAYENTRY))
						    then (SETQ EXCEPTIONS (CONS SUBDICT EXCEPTIONS))
						  else (SETA DICTARRAY ARRAYENTRY (CDR SUBDICT)))
						(SETQ DICT (create DICTIONARY1
								   COMMONSTRING _(fetch (DICTIONARY2
											  
										     COMMONSTRING)
										    of IDCT)
								   ENTRY _(fetch (DICTIONARY2 ENTRY)
									     of DICT)
								   NUMBEROFENTRIES _(fetch
								     (DICTIONARY2 NUMBEROFENTRIES)
										       of DICT)
								   SUBDICTIONARIES _ DICTARRAY
								   EXCEPTIONALSUBDICTIONARIES _ 
								   EXCEPTIONS]
			         (RETURN DICT)))
			 (SHOULDNT))
		    else                                    (* THE ORIGINAL ENTRYNAME EXACTLY MATCHED THE 
							    COMMONSTRING FOR THIS DICTIONARY, THEREFORE WE JUST NEED
							    TO PUT THE NEW ENTRY IN HERE.)
			 (replace (DICTIONARY ENTRY) of DICT with ENTRYVALUE)
			 (if NEWENTRYNAME
			     then (SELECTQ (fetch (DICTIONARY DICTIONARYTYPE)
						  of DICT)
					   (DICTIONARY0 (SHOULDNT))
					   [DICTIONARY1 (replace (DICTIONARY1 NUMBEROFENTRIES)
							   of DICT with (ADD1 (fetch (DICTIONARY1
										       
										  NUMBEROFENTRIES)
										 of DICT]
					   [DICTIONARY2 (replace (DICTIONARY2 NUMBEROFENTRIES)
							   of DICT with (ADD1 (fetch (DICTIONARY2
										       
										  NUMBEROFENTRIES)
										 of DICT]
					   (SHOULDNT)))
			 DICT])

(COPYANDRAISE
  [LAMBDA (ENTRYLST)                                        (* WTL: " 1-DEC-78 13:55")
    (for ENTRY in ENTRYLST collect (if (NLISTP ENTRY)
				       then (CONS (CONCAT (U-CASE (MKSTRING ENTRY)))
						  T)
				     else (CONS [CONCAT (U-CASE (MKSTRING (CAR ENTRY]
						(CDR ENTRY])

(COPYSTRING
  [LAMBDA (STR STRPTR)                                      (* WTL: " 2-DEC-78 10:43")
    (OR (STRINGP STR)
	(SETQ STR (MKSTRING STR)))
    (if (STRINGP STRPTR)
	then (CLOSER (LOC STRPTR)
		     (OPENR (LOC STR)))
	     STRPTR
      else (CONCAT STR])

(CREATEDICTIONARY
  [LAMBDA (ENTRYLST)                                        (* edited: "30-NOV-78 09:13")

          (* EACH ENTRY IN ENTRYLST MAY EITHER BE A STRING (ATOM) OR A DOTTED PAIR OF A STRING AND A USER VALUE TO BE PUT INTO
	  ENTRY. IF JUST ATOMS ARE USED, THENTHE ENTRY INSERTED WILL BE T.)


    (CREATEDICTIONARY1 (COPYANDRAISE ENTRYLST])

(CREATEDICTIONARY1
  [LAMBDA (ENTRYLST)                                        (* WTL: " 2-DEC-78 20:58")

          (* Right here we actually need a test of whether or not all the entries start WITH the same character so that we can
	  stash IT in the common chars VARS.)


    (if (NULL ENTRYLST)
	then NIL
      elseif (NULL (CDR ENTRYLST))
	then                                                (* WE ONLY HAVE ONE ENTRY)
	     (create DICTIONARY0
		     COMMONSTRING _(CAAR ENTRYLST)
		     ENTRY _(CDAR ENTRYLST))
      else (PROG (DICTARRAY EXCEPTIONALENTRIES COMMONCHARS NUMOFENTRIES TRUEENTRY ARRAYENTRY I
			    (COUNT 0))
	     TOP (SETQ NUMOFENTRIES 0)
	         (SETQ EXCEPTIONALENTRIES NIL)
	         (SETQ DICTARRAY (GETNEWDICTIONARYARRAY))
	         [for ENTRY in ENTRYLST do (SETQ NUMOFENTRIES (ADD1 NUMOFENTRIES))
					   (if (ZEROP (NCHARS (CAR ENTRY)))
					       then (SETQ TRUEENTRY (CDR ENTRY))
					     else (SETQ ARRAYENTRY (IDIFFERENCE
						      (CHCON1 (GNC (CAR ENTRY)))
						      64))
						  (if (OR (ILESSP ARRAYENTRY 1)
							  (IGREATERP ARRAYENTRY 26))
						      then (SETQ EXCEPTIONALENTRIES
							     (CONS (CONS (FCHARACTER (IPLUS 
										       ARRAYENTRY 64))
									 ENTRY)
								   EXCEPTIONALENTRIES))
						    else (SETA DICTARRAY ARRAYENTRY
							       (CONS ENTRY (ELT DICTARRAY ARRAYENTRY]

          (* RIGHT HERE WE ACTUALLY NEED A TEST OF WHETHER OR NOT ALL THE ENTRIES START WITH THE SAME CHARACTER SO THAT WE CAN
	  STASH IT IN THE COMMON CHARS VARS.)


	         [for I from 1 to 26 do (SETA DICTARRAY I (CREATEDICTIONARY1 (ELT DICTARRAY I]
	         (SETQ EXCEPTIONALENTRIES (SETUPEXCEPTIONALENTRIES EXCEPTIONALENTRIES))
	         (RETURN (if (ILESSP (PROGN (SETQ COUNT 0)
					    [for I from 1 to 26 do (if (ELT DICTARRAY I)
								       then (SETQ COUNT (ADD1 COUNT]
					    COUNT)
				     MAXDICT2SIZE)
			     then (create DICTIONARY2
					  COMMONSTRING _[AND COMMONCHARS (MKSTRING
							       (PACK (DREVERSE COMMONCHARS]
					  NUMBEROFENTRIES _ NUMOFENTRIES
					  ENTRY _ TRUEENTRY
					  SUBDICTIONARIES _(PROG ((SUBDICTS EXCEPTIONALENTRIES))
							         [for I from 1 to 26
								    do
								     (if (ELT DICTARRAY I)
									 then
									  (SETQ SUBDICTS
									    (CONS
									      (CONS
										(FCHARACTER
										  (IPLUS I 64))
										(ELT DICTARRAY I))
									      SUBDICTS]
							         (FREEDICTARRAY DICTARRAY)
							         (RETURN SUBDICTS)))
			   else (create DICTIONARY1
					COMMONSTRING _[AND COMMONCHARS (MKSTRING (PACK (DREVERSE
											 COMMONCHARS]
					NUMBEROFENTRIES _ NUMOFENTRIES
					SUBDICTIONARIES _ DICTARRAY
					ENTRY _ TRUEENTRY
					EXCEPTIONALSUBDICTIONARIES _ EXCEPTIONALENTRIES])

(FINDINDICTIONARY
  [LAMBDA (STRING DICTIONARY)                               (* WTL: " 2-DEC-78 10:43")
    (PROG ([STR (COPYSTRING STRING (CONSTANT (MKSTRING]
	   ARRAYENTRY
	   (STRPTR (CONSTANT (MKSTRING)))
	   COMMONSTRING)
          (while (NOT (ZEROP (NCHARS STR)))
	     do (OR (type? DICTIONARY DICTIONARY)
		    (GO OUT))
		(if (SETQ COMMONSTRING (fetch (DICTIONARY COMMONSTRING) of DICTIONARY))
		    then (SETQ COMMONSTRING (COPYSTRING COMMONSTRING STRPTR))
			 (while [AND (NOT (ZEROP (NCHARS STR)))
				     (NOT (ZEROP (NCHARS COMMONSTRING]
			    do (if (NEQ (GNC STR)
					(GNC COMMONSTRING))
				   then (SETQ DICTIONARY NIL)
					(GO OUT)))
			 (if (ZEROP (NCHARS STR))
			     then (SETQ DICTIONARY
				    (SELECTQ (fetch (DICTIONARY DICTIONARYTYPE)
						    of DICTIONARY)
					     (DICTIONARY0 (create DICTIONARY0
								  COMMONSTRING _(AND
								    (NOT (ZEROP (NCHARS COMMONSTRING))
									 )
								    (CONCAT COMMONSTRING))
							     reusing DICTIONARY))
					     (DICTIONARY1 (create DICTIONARY1
								  COMMONSTRING _(AND
								    (NOT (ZEROP (NCHARS COMMONSTRING))
									 )
								    (CONCAT COMMONSTRING))
							     reusing DICTIONARY))
					     (DICTIONARY2 (create DICTIONARY2
								  COMMONSTRING _(AND
								    (NOT (ZEROP (NCHARS COMMONSTRING))
									 )
								    (CONCAT COMMONSTRING))
							     reusing DICTIONARY))
					     (SHOULDNT)))
				  (GO OUT)))
		(SELECTQ (fetch (DICTIONARY DICTIONARYTYPE)
				of DICTIONARY)
			 (DICTIONARY0 NIL)
			 [DICTIONARY1 (SETQ ARRAYENTRY (IDIFFERENCE (CHCON1 (GNC STR))
								    64))
				      (if (OR (ILESSP ARRAYENTRY 1)
					      (IGREATERP ARRAYENTRY 26))
					  then [SETQ DICTIONARY
						 (CDR (FASSOC (FCHARACTER (IPLUS ARRAYENTRY 64))
							      (fetch (DICTIONARY1 
								       EXCEPTIONALSUBDICTIONARIES)
								 of DICTIONARY]
					else (SETQ DICTIONARY (ELT (fetch (DICTIONARY1 
										  SUBDICTIONARIES)
								      of DICTIONARY)
								   ARRAYENTRY]
			 [DICTIONARY2 (SETQ DICTIONARY (CDR (FASSOC (GNC STR)
								    (fetch (DICTIONARY2 
										  SUBDICTIONARIES)
								       of DICTIONARY]
			 (SHOULDNT)))
      OUT (RETURN DICTIONARY])

(FREEDICTARRAY
  [LAMBDA (DICTARRAY)                                       (* WTL: " 2-DEC-78 10:57")
    (SETQ EXTRADICTIONARRAY DICTARRAY])

(GETCOMPLETIONSTRING
  [LAMBDA (DICT)                                            (* WTL: " 1-DEC-78 14:33")
    (OR (fetch (DICTIONARY COMMONSTRING) of DICT)
	""])

(GETNEWDICTIONARYARRAY
  [LAMBDA NIL                                               (* WTL: " 1-DEC-78 21:02")
    (if EXTRADICTIONARYARRAY
	then (PROG1 EXTRADICTIONARYARRAY (for I from 1 to 26 do (SETA EXTRADICTIONARYARRAY I NIL))
		    (SETQ EXTRADICTIONARYARRAY NIL))
      else (ARRAY 26])

(GETTOPENTRY
  [LAMBDA (DICT)                                            (* WTL: "30-NOV-78 11:33")
    (if (fetch (DICTIONARY COMMONSTRING) of DICT)
	then NIL
      else (fetch (DICTIONARY ENTRY) of DICT])

(LISTDICTIONARY
  [LAMBDA (DICT PREFIX)                                     (* WTL: " 2-DEC-78 15:45")
    (OR (type? DICTIONARY DICT))
    (if (NULL PREFIX)
	then (SETQ PREFIX "")
      elseif (NOT (STRINGP PREFIX))
	then (SETQ PREFIX (MKSTRING PREFIX)))
    (LISTDICTIONARY1 DICT PREFIX ""])

(LISTDICTIONARY1
  [LAMBDA (DICT PREFIX EXTRACHAR)                           (* WTL: " 2-DEC-78 16:53")
    (PROG ((STARTSTR (CONCAT PREFIX EXTRACHAR (GETCOMPLETIONSTRING DICT)))
	   PARTIALRESULT)
          (SETQ PARTIALRESULT
	    (SELECTQ (fetch (DICTIONARY DICTIONARYTYPE)
			    of DICT)
		     (DICTIONARY0 NIL)
		     [DICTIONARY1 (PROG ((DICTARRAY (fetch (DICTIONARY2 SUBDICTIONARIES)
						       of DICT))
					 I)
				        (RETURN (APPEND [for I from 1 to 26 when (ELT DICTARRAY I)
							   join (LISTDICTIONARY1 (ELT DICTARRAY I)
										 STARTSTR
										 (FCHARACTER
										   (IPLUS I 64]
							(for SUBDICT in (fetch (DICTIONARY1 
								       EXCEPTIONALSUBDICTIONARIES)
									   of DICT)
							   join (LISTDICTIONARY1 (CDR SUBDICT)
										 STARTSTR
										 (CAR SUBDICT]
		     [DICTIONARY2 (for SUBDICT in (fetch (DICTIONARY2 SUBDICTIONARIES) of DICT)
				     join (LISTDICTIONARY1 (CDR SUBDICT)
							   STARTSTR
							   (CAR SUBDICT]
		     (SHOULDNT)))
          (if (fetch (DICTIONARY ENTRY) of DICT)
	      then (RETURN (CONS (CONS STARTSTR (fetch (DICTIONARY ENTRY) of DICT))
				 PARTIALRESULT))
	    else (RETURN PARTIALRESULT])

(NUMOFENTRIES
  [LAMBDA (DICT)                                            (* WTL: " 1-DEC-78 13:32")
    (OR (fetch (DICTIONARY NUMBEROFENTRIES) of DICT)
	1])

(SETUPEXCEPTIONALENTRIES
  [LAMBDA (EXCEPTIONALENTRIES)                              (* WTL: " 1-DEC-78 15:10")
    (if (NULL EXCEPTIONALENTRIES)
	then NIL
      else (PROG [(EXCEPTLST (LIST (LIST (CAAR EXCEPTIONALENTRIES)
					 (CDAR EXCEPTIONALENTRIES]
	         (for ENTRY in (CDR EXCEPTIONALENTRIES)
		    do (PUTASSOC (CAR ENTRY)
				 (CONS (CDR ENTRY)
				       (CDR (FASSOC (CAR ENTRY)
						    EXCEPTLST)))
				 EXCEPTLST))
	         [for EXCEPT in EXCEPTLST do (RPLACD EXCEPT (CREATEDICTIONARY1 (CDR EXCEPT]
	         (RETURN EXCEPTLST])
)

(RPAQQ DICTIONARYRECORDS (DICTIONARY DICTIONARY0 DICTIONARY1 DICTIONARY2))
[DECLARE: EVAL@COMPILE 

(RECORD DICTIONARY (DICTIONARYTYPE COMMONSTRING ENTRY NUMBEROFENTRIES)
		   DICTIONARY @ (OR (TYPE? DICTIONARY0 DATUM)
				    (TYPE? DICTIONARY1 DATUM)
				    (TYPE? DICTIONARY2 DATUM))
		   (* COMMONSTRING IS THE STRING WHICH IS COMMON TO EVERY ENTRY AT OR BELOW THIS 
		      NODE. I.E. IT IS THE STRING WHICH MUST BE PRESENT TO OBTAIN ENTRY AND MUST BE 
		      PRESENT BEFORE ENTERING THE SUBDICTIONARIES. NUMBEROFENTRIES INDICATES HOW MANY 
		      ENTRIES ARE AT OR BELOW THIS LEVEL IN THE DICTIONARY. NOTE THAT IT COUNTS 
		      ENTRY. SUBDICTIONARY IS THE ARRAY OF 26 SUBDICTIONARIES.)
		   (* Right now it is assumed that everything is in upper case.))

(TYPERECORD DICTIONARY0 (COMMONSTRING ENTRY)
			(* THIS IS FOR DICTIONARIES THAT CONTAIN ONLY ONE ENTRY))

(TYPERECORD DICTIONARY1 (COMMONSTRING ENTRY NUMBEROFENTRIES SUBDICTIONARIES 
				      EXCEPTIONALSUBDICTIONARIES)
			(* THIS IS FOR THE MOST GENERAL FORM OF THE DICTIONARY))

(TYPERECORD DICTIONARY2 (COMMONSTRING ENTRY NUMBEROFENTRIES SUBDICTIONARIES)
			(* THIS IS FOR DICTIONARIES OF LOW BRANCHING ORDER. < APP 7)
			(* THE SUBDICTIONARIES ARE AN ALST))
]

(RPAQQ DICTIONARYVARS (MAXDICT2SIZE TESTENTRYLIST (EXTRADICTIONARYARRAY NIL)))

(RPAQQ MAXDICT2SIZE 6)

(RPAQQ TESTENTRYLIST ((ORNSTEIN . ALEXANDER)
		      (FIALA . ALEXANDER)
		      (GIFFORD . ALEXANDER)
		      (LAASER . ALEXANDER)
		      (MORRIS . ALEXANDER)
		      (RAMSHAW . ALEXANDER)
		      (SCOTT . ALEXANDER)
		      (SOSINSKI . ALEXANDER)
		      (TAFT . ALEXANDER)
		      (THOMPSON . ALEXANDER)
		      (YEARY . ALEXANDER)
		      (KAY . MORTON)
		      (BATES . MORTON)
		      (BOBROW . MORTON)
		      (BOGGS . MORTON)
		      (DEUTSCH . MORTON)
		      (FIKES . MORTON)
		      (KOLLING . MORTON)
		      (MASINTER . MORTON)
		      (OVERTON . MORTON)
		      (STURGIS . MORTON)
		      (WINOGRAD . MORTON)
		      (TAYLOR . JENKINS)
		      (KAPLAN . JENKINS)
		      (MCCREIGHT . JENKINS)
		      (THACKER . JENKINS)
		      (MITCHELL . DAKE)
		      (CROWTHER . DAKE)
		      (GOLDSTEIN . DAKE)
		      (HAUGELAND . DAKE)
		      (ISRAEL . DAKE)
		      (LAMPSON . DAKE)
		      (LEVIN . DAKE)
		      (PERLIS . DAKE)
		      (SWINEHART . DAKE)
		      (TEITELMAN . DATE)
		      (GESCHKE . SARGENT)
		      (BIRRELL . SARGENT)
		      (CATTELL . SARGENT)
		      (CLARK . SARGENT)
		      (GUIBAS . SARGENT)
		      (HORNING . SARGENT)
		      (MALESON . SARGENT)
		      (MCDANIEL . SARGENT)
		      (PIER . SARGENT)
		      (SCHROEDER . SARGENT)
		      (SUZUKI . SARGENT)
		      (WARNOCK . SARGENT)
		      ALEXANDER MORTON JENKINS DAKE SARGENT))

(RPAQ EXTRADICTIONARYARRAY NIL)

(RPAQQ DICTIONARYBLOCKS ((DICTIONARY ADDTODICTIONARY ADDTODICTIONARY1 COPYANDRAISE COPYSTRING 
				     CREATEDICTIONARY CREATEDICTIONARY1 FINDINDICTIONARY 
				     FREEDICTARRAY GETCOMPLETIONSTRING GETNEWDICTIONARYARRAY 
				     GETTOPENTRY LISTDICTIONARY LISTDICTIONARY1 NUMOFENTRIES 
				     SETUPEXCEPTIONALENTRIES (ENTRIES ADDTODICTIONARY 
								      CREATEDICTIONARY 
								      FINDINDICTIONARY GETTOPENTRY 
								      LISTDICTIONARY NUMOFENTRIES)
				     (LOCALFREEVARS NEWENTRYNAME))))
[DECLARE: DONTEVAL@LOAD DOEVAL@COMPILE DONTCOPY
(BLOCK: DICTIONARY ADDTODICTIONARY ADDTODICTIONARY1 COPYANDRAISE COPYSTRING CREATEDICTIONARY 
	CREATEDICTIONARY1 FINDINDICTIONARY FREEDICTARRAY GETCOMPLETIONSTRING GETNEWDICTIONARYARRAY 
	GETTOPENTRY LISTDICTIONARY LISTDICTIONARY1 NUMOFENTRIES SETUPEXCEPTIONALENTRIES
	(ENTRIES ADDTODICTIONARY CREATEDICTIONARY FINDINDICTIONARY GETTOPENTRY LISTDICTIONARY 
		 NUMOFENTRIES)
	(LOCALFREEVARS NEWENTRYNAME))
]
(DECLARE: DONTCOPY
  (FILEMAP (NIL (845 18550 (ADDTODICTIONARY 857 . 1412) (ADDTODICTIONARY1 1416 . 8725) (COPYANDRAISE 
8729 . 9066) (COPYSTRING 9070 . 9362) (CREATEDICTIONARY 9366 . 9751) (CREATEDICTIONARY1 9755 . 12761) 
(FINDINDICTIONARY 12765 . 15151) (FREEDICTARRAY 15155 . 15306) (GETCOMPLETIONSTRING 15310 . 15492) (
GETNEWDICTIONARYARRAY 15496 . 15829) (GETTOPENTRY 15833 . 16079) (LISTDICTIONARY 16083 . 16415) (
LISTDICTIONARY1 16419 . 17753) (NUMOFENTRIES 17757 . 17934) (SETUPEXCEPTIONALENTRIES 17938 . 18547))))
)
STOP