;(READ-EOF #FILE-IN-|DSK:SHRDLU;SMSPEC LSP|-70760) END OF FILE WITHIN READ
;BKPT FAIL-ACT
SMSPEC:
(declare (genprefix smspec))
(DEFUN SMTIME NIL (ERT SMTIME NOT WRITTEN YET))
(DEFUN SMTIME2 NIL (ERT SMTIME2 NOT WRITTEN YET))
(DEFUN SMNEWNOUN NIL
(OBJECT (MARKERS: (/#NEWNOUN) PROCEDURE: ((/#NEWWORD)))))
(DEFUN SMNEWPROPN NIL (SMSET (LIST (NEWCOPY 'NAME-OSS))))
(DEFUN SMCONJ NIL
;;FOR ALL CONJOINED THINGS -- IT CURRENTLY ONLY HANDLES THINGS
;;WHICH HAVE AN OSS OR RSS STRUCTURE AS THEIR SEMANTICS. THIS
;;DOES NOT INCLUDE SINGLE WORDS OF MOST TYPES. IT USES
;;RECURSION
(PROG (%SM) (SMCONJ2 NIL H) (RETURN (SMSET %SM))))
(DEFUN SMCONJ2 (INTERPLIST RESTLIST)
;;INTERPLIST IS THE LIST OF INTERPRETATIONS FOR THE CONJUNCTS
;;HANDLED SO FAR -- THIS FUNCTION WILL BE CALLED ONCE FOR EACH
;;POSSIBLE COMBINATION. THE MARKERS FOR THE CONJOINED
;;STRUCTURE ARE THOSE OF THE FIRST CONJUNCT -- NEEDS MORE
;;SOPHISTICATION. RESTLIST IS THE REST OF NODES YET TO BE
;;HANDLED.
(PROG (%X)
(OR RESTLIST
(RETURN (SETQ %SM
(CONS (BUILD RSSNODE=
(AND (RSS? INTERP)
(MAKESYM 'RSS))
OSSNODE=
(AND (OSS? INTERP)
(MAKESYM 'OSS))
MARKERS=
(MARKERS? INTERP)
SYSTEMS=
(SYSTEMS? INTERP)
REL=
(REL? INTERP)
AND=
(AND (OR (CQ BUT)
(CQ AND))
INTERPLIST)
OR=
(AND (OR (CQ OR) (CQ NOR))
INTERPLIST))
%SM))))
;WHEN THERE IS NO RESTLIST,
(MAPCAR '(LAMBDA (INTERP) (SMCONJ2 (CONS INTERP
INTERPLIST)
;WE HAVE LOOPED TO THE END OF
(CDR RESTLIST)))
;THE LIST OF CONJUNCTS, AND
(SM RESTLIST))))
;THE RESULTING INTERPRETATION IS OK. THE MAPPING
;IS DOWN THE LIST OF INTERPRETATIONS FOR A
;SINGLE CONJUNCT WHILE THE RECURSION GETS US
;DOWN THE LIST OF CONJUNCTS. THUS WE GET EVERY
;POSSIBLE COMBINATION OF THE INTERPRETATIONS. --
;ISN'T LISP SUPER-DUPER-WONDERFUL! NOTICE THAT
;INTERP IS GETTING PICKED UP AS A FREE VARIABLE
;BY SMCONJ2, EVEN THOUGH IT IS BOUND ONLY INSIDE
;A MAPCAR INSIDE SMCONJ2. THIS WORKS BECAUSE THE
;CLAUSE CONTAINING IT CAN NEVER GET CALLED
;EXCEPT BY RECURSION,
(DEFUN SMVG NIL
;;CALLED INSIDE ANY VG
(PROG (TSS TENSE)
(SETQ TSS (GETR 'TIME (MOVE-PT C U (CLAUSE))))
(AND (CQ NEG) (ADD-F-PT 'NEG PT))
;NEG IS TRANSFERRED FROM THE
(SETQ TENSE (GETR 'TENSE C))
;VG TO THE CLAUSE IN WHICH IT
(COND ((MEMBER TENSE
'((PRESENT) (IMPER) (INFINITIVE)))
T)
;IS EMBEDDED.
((EQUAL TENSE '(MODAL))
(SETQ GLOBAL-MESSAGE '(THAT DOESN/'T
MAKE
ANY
SENSE
TO
ME/.))
(ADD-F-PT 'MODAL PT))
;CLAUSES ARE ALSO MARKED AS
((AND (EQUAL TENSE '(FUTURE))
;MODAL.
(ISQ PT QUEST)
(EQUAL (REFER? (CAR (SM (GETR 'SUBJECT
PT))))
'(:SHRDLU)))
; FUTURE QUESTIONS WITH /"YOU/"
(SETQ TENSE '(PRESENT))
;SUBJECT IS REALLY IMPERATIVE
(REMOVE-F-PT 'QUEST PT)
; THE CLAUSE IS NO LONGER
(ADD-F-PT 'IMPER PT))
;QUESTION BUT RATHER,
((SETDIF TENSE '(PAST PRESENT))
;IMPERATIVE
(GLOBAL-ERR '(I DON/'T
KNOW
HOW
TO
HANDLE
TENSES
INVOLVING
FUTURE
EVENTS
OR
MODALS
OTHER
THAN
IN
THE
PRESENT))))
(PUTPROP TSS TENSE 'TENSE=)
(RETURN T)))
(DEFUN SMADJGQSHORT NIL (ERT SMADJQSHORT NOT WRITTEN YET))
(DEFUN SMPRON (NODE)
(EVAL (SM NODE))
(COND ((NULL SM)
(SETQ GLOBAL-MESSAGE (APPEND '(I DON/'T KNOW WHAT /")
(FROM (NB H) (N H))
'(/" REFERS TO)))))
SM)
(DEFUN SMVAUX NIL
(COND ((ISQ H NEG) (FQ NEG)) (T))
(PUTPROP (GETR 'TIME C)
(OR (MEET (FE H) '(PRESENT PAST MODAL))
(ERTERR SMVAUX -- FUNNY TENSE))
'TENSE=))
(DEFUN SMADV NIL (ERT SMADV NOT WRITTEN YET))
(DEFUN SMPLACE NIL (ERT SMPLACE NOT WRITTEN YET))
(DEFUN SMTOADJ NIL (ERT SMTOADJ (UNCT) NOT WRITTEN YET))
(DEFUN SMPROP NIL
;;THIS IS THE SEMANTICS FOR PROPER NOUNS. IT PRODUCES TWO
;;INTERPRETATIONS. ONE IS THE OPAQUE REFERENCE TO THE NAME
;;ITSELF, AS IN /"CALL IT SAM/". THE OTHER IS THE TRANSPARENT
;;REFERENT AS IN /"PICK UP SAM/".
(SMSET (LIST (BUILD OSSNODE=
(MAKESYM 'OSS)
VARIABLE=
'NAME
DETERMINER=
(1. DEF NIL)
PARSENODE=
C
MARKERS=
(/#NAME)
REFER=
(LIST (WORD (NB H))))
(BUILD OSSNODE=
(MAKESYM 'OSS)
DETERMINER=
(1. DEF NIL)
PARSENODE=
C
VARIABLE=
(MAKESYM 'X)
RELATIONS=
(LIST (LIST '/#NAME
OSSNODE=
(WORD (NB H)))))))
(SMNG2))
(DEFUN SMADJ (WORD-BEING-INTERPRETED)
;; THIS FUNCTION TAKES AS INPUT THE PARSE NODE FOR AN
;;ADJECTIVE - NOT COMPARATIVE OR SUPERLATIVE. IT JUST EVAL'S
;;THE DEFINITION. THAT DEFINITION (WHICH SHOULD BE AN NMEANS)
;;MAP'S DOWN THE LIST OF OSS'S IN THE FREE VARIABLE /"SM/". IT
;;CHECKS FOR MARKER COMPATIBILITY AND ATTACHES ITS /"PLANNER/"
;;TO THAT OF THE OSS. IT SHOULD MAKE UP NEW OSS'S IN CASE OF
;;MULTIPLE INTERPRETATIONS OF THE PHRASE. THE OSS'S IT
;;CREATES ARE LEFT IN THE FREE VARIABLE /"SM/". THIS FUNCTION
;;CALLED BY: SMNG1 IT NEEDS TO BE HAIRED UP FOR CONJOINED
;;ADJECTIVES LIKE /"GREEN AND RED BALL/".
(EVAL (SM WORD-BEING-INTERPRETED)))
; EVALUATE THE DEFINITION OF THE ADJECTIVE
;;---------------------------------------------
;;;--------------------------------------------
(DEFUN SMADJG-PREPG NIL
;HANDLES ADJECTIVE GROUPS AND
(PROG (X SMSUB)
;PREPGS BOTH AS COMPLEMENTS
(AND (OR (CQ AGENT) (CQ OF)) (RETURN T))
;AND QUALIFIERS DO NOTHING
(SETR 'LOGICAL-SUBJECT
;FOR /"BY/" PHRASES IN PASSIVE
(COND ((CQ COMP)
(GETR 'SUBJECT
(MOVE-PT C U (CLAUSE))))
;CLAUSES OR /"OF/" PHRASES LIKE
((CQ LOBJ)
;IN THREE OF THE BLOCKS.
(OR (GETR 'OBJ1
(MOVE-PT C U (CLAUSE)))
;SEMANTIC SUBJECT IS THE
(GETR 'SUBJECT PT)))
;SUBJECT OF AN INTENSIVE OR
((ISQ (MOVE-PT C
U
(NOT (ISQ PT COMPONENT))
U)
NG)
PT)
;THE NG TO WHICH THE GROUP IS
((ISQ PT CLAUSE) PT)
;A QUALIFIER, OR THE CLAUSE
((ERTERR SMADJG-PREPG FUNNY POSITION)))
;OF WHICH IT IS AN ADJUNCT.
C)
(SETQ SMSUB (SM (GETR 'LOGICAL-SUBJECT C)))
(AND (CQ ADJG)
(GETR 'OBJ1 C)
(SETR 'ADJGHEAD
(COMPARE-BUILD (GETR 'HEAD C)
(COND ((CQ AS) '/#ASMUCH)
((CQ THAN) '/#MORE)
((ERTERR SMADJG-PREPG
FUNNY
TYPE))))
C))
(COND
((GETR 'OBJ1 C) (SMCL1) (RETURN SM))
((RETURN
(SMSET
(PROG (SM)
(SMSET (MAPCAR
'(LAMBDA (OSS)
(BUILD OSSNODE=
(MAKESYM 'OSS)
MARKERS=
(MARKERS? OSS)
SYSTEMS=
(SYSTEMS? OSS)
VARIABLE=
(VARIABLE? OSS)
REFER=
(REFER? OSS)
REL=
OSS
REFER=
(REFER? OSS)
DETERMINER=
'(NS-PL INDEF NIL)))
SMSUB))
(EVAL (COND ((OR (CQ COMPAR) (CQ SUP))
(FINDMEASURE (GETR 'HEAD
C)))
(T (SM (GETR 'HEAD C)))))
(RETURN SM))))))))
;;;--------------------------------------------
(DEFUN SMIT (PRONOUN)
; PRONOUN IS (IT THEY ONE)
(PROG (CANDIDATES AMBIGUITIES)
; A NODE LIST OF POSSIBLE
(OR DISCOURSE (ERT SMIT: DISCOURSE SWITCH NOT ON))
;REFERENTS
(AND MVB;IS THIS A /"DO IT!/" COMMAND?
(ISQ MVB DO)
(CQ OBJ1)
(RETURN (SMSET LASTEVENT)))
;IF SO, RETURN THE LAST EVENT
(COND ((GET PRONOUN 'BIND)
;MENTIONED IF THIS PRONOUN
(MAP (FUNCTION (LAMBDA (BINDNODE)
(SMIT2 BINDNODE 0.)))
;HAS BEEN USED BEFORE IN THIS
(GET PRONOUN 'BIND))
;SENTENCE THEN USE THE SAME
(RETURN SM))
;CANDIDATES
((SMIT2 (GET PRONOUN 'LASTBIND) 0.)
; IF THIS PRONOUN WAS USED IN
(GO DONE))
;THE PREVIOUS SENTENCE
((OR (MOVE-PT C U U (NG) U U (NG))
;LOOK FOR A STRUCTURE LIKE /"
(MOVE-PT C U U (NG) U (COMP) PV (SUBJ)))
;A BLOCK WHICH IS TALLER THAN
(SMIT2 PT 0.)
;ANYTHING WHICH SUPPORTS IT/"
(MOVE-PT C U U (NG))
;OR /"A
(COND ((ISQ PT DEF)
(ADD-F-PT 'INDEF PT)
(REMOVE-F-PT 'DEF PT)
(MAPC '(LAMBDA (INTERP)
(PUTPROP INTERP
'((EXACTLY 1.)
INDEF
NIL)
'DETERMINER=))
(SM PT))))
(RETURN SM))
;BLOCK TALLER THAN ANYTHING
((OR (MOVE-PT C U (BOUND) U)
;WHICH SUPPORTS IT/"
(MOVE-PT C
U
(AND (ISQ PT CLAUSE)
(ISQ PT COMPONENT))
U
DLC))
(SMIT2 (GETR 'OBJ2 PT) 0.)
(SMIT2 (GETR 'OBJ1 PT) 0.)
(SMIT2 (GETR 'SUBJECT PT) 0.)
(AND (NULL SM)
(ISQ PT RSQ)
(SMIT2 (GETR 'RELHEAD PT) 0.))
(AND SM (RETURN SM))))
(SMIT2 (GETR 'SUBJECT LASTSENT) 192.)
(SMIT2 (PARSENODE? LASTREL) 128.)
;TRY REL (I.E. QUESTION FOCUS
(MOVE-PT LASTSENT DLC)
;) OF THE LAST SENTENCE. GO
UP (COND ((NOT (MOVE-PT PV (NG))) (GO ON))
(ELSE (SMIT2 PT 64.)))
;THROUGH TOP LEVEL NG'S OF
(AND (MOVE-PT PV) (GO UP))
;LAST SENTENCE
ON (OR SM ; IF WE HAVEN'T YET FOUND A
(MAP (FUNCTION (LAMBDA (ANSNODE) (SMIT2 ANSNODE 0.)))
;REFERENT MAP DOWN THE ANSREF
ANSNAME))
;(NG'S IN LAST ANSWER)
(OR SM ; IF WE HAVEN'T YET FOUND A
(MAP
(FUNCTION (LAMBDA (BACKNODE) (SMIT2 BACKNODE 0.)))
;REFERENT MAP DOWN THE
BACKREF2))
;BACKREF2 (NG'S IN LAST
DONE (PUTPROP PRONOUN CANDIDATES 'BIND)
;SENTENCE) LIST
(OR (CDR SM) (REMPROP (CAR SM) 'AMBIGUITIES=))
(RETURN SM)))
(DEFUN SMIT2 (NODE PLAUSIBILITY)
(AND
NODE ; MAKE SURE NODE IS REALLY
(GETR 'HEAD NODE)
;THERE QUEST NODES (SUCH AS
(NOT (MEMQ (CAR NODE) CANDIDATES))
;/"WHAT/") OR OTHER NODES WITHOUT HEAD NOUNS ARE
(COND ((EQ PRONOUN 'IT)
;NOT SUITABLE FOR REFERENTS MAKE SURE THAT NODE
(AND (ISQ NODE NS) (NOT (ISQ NODE PRONG))))
;HASN'T ALREADY BEEN USED AS
(ELSE (ISQ NODE NPL)))
;REFERENT MAKE SURE NODE AND
(SETQ CANDIDATES (CONS (CAR NODE) CANDIDATES))
;PRONOUN AGREE IN NUMBER
(SMSET
(NCONC
(MAPCAR
(FUNCTION
(LAMBDA (REFERENT-OSS)
(BUILD OSSNODE=
(MAKESYM 'OSS)
MARKERS=
(MARKERS? REFERENT-OSS)
SYSTEMS=
(SYSTEMS? REFERENT-OSS)
PLAUSIBILITY=
PLAUSIBILITY
AMBIGUITIES=
(LIST (LIST OSSNODE=
(FROM (NB NODE) (N NODE))
C))
REFER=
(REFER? REFERENT-OSS)
VARIABLE=
(VARIABLE? REFERENT-OSS)
; INPUT PARAMETER
PARSENODE=
C
; USE THE REFERENT'S REFERENT
DETERMINER=
;IF IT HAS ONE
(LIST (COND ((ISQ C NPL) 'NPL)
('NS))
'INDEF
NIL)
RELATIONS=
(LIST (LIST '/#REFERS
; DONE SO THAT IF VARIBLE IS BOUND, PLANNER
(VARIABLE? REFERENT-OSS))))))
;GENERATOR WILL USE IT RELATION SAYS
(SM NODE));THAT THIS OSS /"REFERS/" TO
SM)))) ;THE OSS WHOSE VARIABLE NAME IS GIVEN END OF
;BUILD
(DEFUN SMNGOF NIL
;; USED TO PROCESS NOUN GROUPS LIKE= /"THREE OF THE BLOCKS/"
;;/"BOTH OF THEM/"
;;;
;; SINCE THE OBJECT OF THE /"OF/" MUST BE
;;DEFINITE(SYNTACTICALLY) AND HAS ALREADY BEEN PROCESSED, THE
;;PLANNER CODE BUILT IS JUST A THAMONG EXPRESSION OF THE LIST
;;OF POSSIBLE REFERENTS OF THE /"OF/" OBJECT
;;;
(SMSET
(MAPBLAND
(FUNCTION
(LAMBDA (OFOSS)
(BUILD OSSNODE=
(MAKESYM 'OSS)
VARIABLE=
(VARIABLE? OFOSS)
SYSTEMS=
(SYSTEMS? OFOSS)
MARKERS=
(MARKERS? OFOSS)
PARSENODE=
C
DETERMINER=
(LIST (COND ((CQ NUM)
(SM (MOVE-PT H PV (NUM))))
((ISQ NB BOTH) 2.)
('NPL))
(COND ((MOVE-PT H PV (QNTFR))
(EVAL (SM PT)))
('INDEF))
(COND ((CQ HOWMANY) 'HOWMANY)
((CQ QDET) 'WHICH)))
RELATIONS=
(LIST (LIST 'THAMONG
(LIST 'THV
(VARIABLE? OFOSS))
(LIST 'QUOTE
(REFER? OFOSS)))))))
(SM (MOVE-PT H DLC)))))
;MAP DOWN THE LIST OF /"OF/" OBJECT
;INTERPRETATIONS
;;;=============================================================
(DEFUN SMNG1 NIL
;;; SMNG1 IS CALLED AS SOON AS TJHE HEAD OF A NOUN GROUP IUS
;;PARSED. IT FIRST BUILDS A SKELETON OSS CONTAINING ONLY THE
;;DETERMINERS AND ORDINALS. IT THEN EVAL'S THE DICTIONARY
;;DEFINITION OF THE HEAD NOUN WHICH SHOULD BUILD OSS'S FOR
;;EACH POSSIBLE INTERPRETATION OF THE NOUN. IT THEN CYCLES
;;THROUGH ALL THE GOODIES IN FROUNT OF THE HEAD NOUN, EVALING
;;THEIR DEFINITIONS. THE FREE VARIABLE /"SM/" IS USED TO KEEP
;;THE LIST OF OSS'S DURING THIS ENTIRE PROCESS. ; NOTE THE
;;SPECIAL HANDLING OF TPRONS (ANYTHING SOMETHING ETC.) AND OF
;;SUPERLATIVE AND COMPARATIVE ADJECTIVES. ;
(PROG (WORD-BEING-INTERPRETED DETERS)
(SETQ DETERS
(LIST (COND ((CQ NUMD)
((LAMBDA (NUM)
(EVAL (SM (MOVE-PT H
PV
(NUMD)))))
(SM (MOVE-PT H PV (NUM)))))
((CQ NUM) (SM (MOVE-PT H PV (NUM))))
((CQ NPL)
(COND ((ISQ NB BOTH) 2.)
((CQ NS) 'SG-PL)
('NPL)))
('NS))
(COND ((CQ QNTFR)
(EVAL (SM (MOVE-PT H PV (QNTFR)))))
((CQ TPRON)
(EVAL (SM (MOVE-PT H PV (TPRON)))))
((CQ DEF) 'DEF)
((CQ DET) 'INDEF)
('NDET))
(COND ((CQ HOWMANY) 'HOWMANY)
((CQ QDET) 'WHICH))))
;;;
(SMSET (LIST (BUILD OSSNODE=
(MAKESYM 'OSS)
PARSENODE=
C
VARIABLE=
(MAKESYM 'X)
MARKERS=
(AND (CQ TPRON)
'(/#VAGUE /#PHYSOB /#THING))
RELATIONS=
(AND (CQ TPRON)
(LIST (LIST '/#PHYSOB
OSSNODE=)))
DETERMINER=
DETERS)))
;BUILD AN INITIAL OSS
(SETQ WORD-BEING-INTERPRETED H)
;SETUP TO LOOP THROUGH
(COND ((ISQ H TPRON) (GO LOOP))
;ADJECTIVES IF ITS A TPRON,
((CQ INCOM) (SMONE) (GO LOOP)))
;ITS WAS EVALED ABOVE SO SKIP
(SMSET (EVAL (SM WORD-BEING-INTERPRETED)))
;INCOMPLETES SUCH AS /"PICK UP
LOOP (COND ((NULL SM) (RETURN NIL)))
;TWO/" EVAL THE HEAD NOUN IF
(COND ((NULL (SETQ WORD-BEING-INTERPRETED
(CDR WORD-BEING-INTERPRETED)))
;AN ADJECTIVE ELIMINATES ANY
(RETURN SM))
;POSSIBLE INTERPRETATION FOR
((OR (ISQ WORD-BEING-INTERPRETED COMPAR)
;THIS NG, FAIL IF WE'VE
(ISQ WORD-BEING-INTERPRETED SUP))
;LOOPED THRU ALL THE MODIFIERS, THEN RETURN THE
(EVAL (FINDMEASURE WORD-BEING-INTERPRETED))
;LIST OF POSSIBLE INTERPRETATIONS. IF ITS A
(GO LOOP))
;COMPARATIVE OR SUPERLATIVE
((OR (ISQ WORD-BEING-INTERPRETED ADJ)
;ADJECTIVE
(ISQ WORD-BEING-INTERPRETED CLASF))
; IF ITS AN ADJECTIVE OR
(SMADJ WORD-BEING-INTERPRETED)
;CLASSIFIER THEN EVAL THE
(GO LOOP))
;DICTIONARY DEFINITION OF IT
((ISQ WORD-BEING-INTERPRETED POSS)
(SMPOSS)
(GO LOOP)))
(GO LOOP)))
;;;=============================================================
(DEFUN SMNG2 NIL
;; CALLED FROM NG WHEN ALL QUALIFIERS HAVE BEEN FOUND.
;;BASICALLY, IT SAVE THE NG ON THE BACKREF(ERENCE) LIST, AND
;;CALLS SMNG3 (ON EACH POSSIBLE NG INTERPRETATION) TO EVAL ANY
;;DEFINITE NOUN GROUPS EG. /"THE RED BLOCK./" AS USUAL, THE
;;INITIAL OSS LIST IS IN /"SM/" AND THE FINAL OSS LIST IS PUT IN
;;/"SM/" ;
(AND (NOT (CQ ANSNAME))
; DON'T USE FAKEY ANSWER NAME
(GETR 'HEAD C)
;NODES FOR REFERENCE QUEST
DISCOURSE;NODES ARE NOT SUITABLE
(SETQ BACKREF (CONS (CAR C) BACKREF)))
;REFERENTS SAVE THIS NG AWAY
(SMSET (MAPBLAND (FUNCTION SMNG3) SM)))
;FOR POSSIBLE LATER BACK REFERENCE GO THRU ALL
;THE POSSIBLE INTERPRETATIONS OF THIS NOUN GROUP
(DEFUN SMNG3 (OSS)
;; TAKES AN OSS AS ARGUMENT AND TRIES TO FIND ITS REFERENCE IF
;;THE NOUN GROUP IS DEFINITE. EXCEXT FOR SPECIAL /"ONLY
;;DEFINITE/" DEFINITES SUCH AS /"THE RIGHT/" AND /"THE THING/"
(PROG (FINDER MUNG INTER LIST CANDIDATES UNBOUND)
(COND ((NOT (EQ (QUANTIFIER? OSS) 'DEF))
(RETURN OSS))
;IF ITS NOT DEFINITE OR IT
((REFER? OSS) (RETURN OSS))
;ALREADY HAS A REFERENT
((CQ ANSNAME) (RETURN OSS)))
;MARKED, IF ITS KLUDGY
(SETQ
FINDER
(PLNR-FINDIFY 'ALL
;ANSWER NAME, JUST RETURN IT
(VARIABLE? OSS)
;JUST RETURN IT
(LIST (VARIABLE? OSS))
(PLNR-DESCRIBE (RELATIONS? OSS)
(VARIABLE? OSS)
(LIST (VARIABLE? OSS)))))
; BUILDS UP THFIND EXPRESSION
(PUTPROP OSS FINDER 'PLNRCODE=)
(SETQ WHO NIL)
UP (COND ((NOT (SETQ CANDIDATES (THVAL2 WHO FINDER)))
(GO TOOFEW))
((NUMBERP (NUMBER? OSS))
(COND ((LESSP (LENGTH CANDIDATES) (NUMBER? OSS))
(GO TOOFEW))
((GREATERP (LENGTH CANDIDATES)
(NUMBER? OSS))
(GO TOOMANY))))
((EQ (NUMBER? OSS) 'NS)
(COND ((NULL CANDIDATES) (GO TOOFEW))
((CDR CANDIDATES) (GO TOOMANY))))
((MEMQ (NUMBER? OSS) '(NPL SG-PL)))
((ERT SMNG3= SCREWY NUMBER PROPERTY OF OSS)))
;;;
(PUTPROP OSS CANDIDATES 'REFER=)
DONE (RETURN OSS)
;;;
TOOFEW ; WE DIDN'T FIND ANY (OR
(COND ((OR (NULL DISCOURSE) (NULL WHO))
;ENOUGH) REFERENTS FOR THE NG
(SETQ GLOBAL-MESSAGE (APPEND '(I DON/'T
KNOW
WHAT
YOU
MEAN
BY
/")
(FROM NB N)
'(/"/.)))
(RETURN NIL))
;IF WE AREN'T REMEMBERING
((MEMQ WHO '(HE NIL))
;SENTENCES, FORGET IT IF WE JUST TRIED TO FIND
(SETQ GLOBAL-MESSAGE (APPEND '(I DON/'T
KNOW
WHICH)
;EVERYTHING (OR EVERYTHING
(CDR (FROM NB N))
;THAT /"HE/" KNOWS ABOUT)
'(YOU MEAN/.)))
;THEN FAIL
(RETURN NIL)))
(SETQ MUNG T)
; ELSE SET UP TO EXPAND THE
TOOMANY ;SENTENCES WE'RE LOOKING AT
(AND (MEMQ WHO '(HE NIL))
(SETQ FINDER (PLNR-MUNG FINDER CANDIDATES)))
;RESTRICT THE POSSIBLE
(SETQ WHO
(COND ((EQ WHO NIL) 'HE)
;REFERENTS TO BE AMUNG THE
((EQ WHO 'HE)
;LIST ALREADY FOUND
(LIST (SUB1 LASTSENTNO) (ADD1 LASTSENTNO)))
((OR (NOT MUNG) (EQ (CAR WHO) 1.))
(SETQ WHO 'HE)
(GO TOOFEW))
((CONS (SUB1 (CAR WHO)) (CDR WHO)))))
(SETQ MUNG NIL)
(GO UP)))
(DEFUN SMONE NIL
(PROG (CONTRAST X)
(SETQ X H)
; SET X TO DAUGHTERS OF
GO (COND ((SETQ CONTRAST (GET (ROOT (NB X))
'CONTRAST))
;CURRENT NODE
(SETQ CONTRAST (LIST CONTRAST (ROOT (NB X)))))
((SETQ X (CDR X)) (GO GO)))
UP (OR (AND (MOVE-PT C U U (NG)) (SMONE2 (LIST (CAR PT))))
(SMONE2 (PARSENODE? LASTREL))
(SMONE2 BACKREF)
(SMONE2 ANSNAME)
(SMONE2 BACKREF2)
(COND (CONTRAST (SETQ CONTRAST NIL) (GO UP)))
(AND (MOVE-PT LASTSENT DLC PV (NG))
(SMONE2 (LIST (CAR PT))))
(ERT SMONE= CAN/'T FIND REFERENT FOR /"ONE/"))
(RETURN SM)))
(DEFUN SMONE2 (X)
;; SMONE2 TAKES IN A LIST OF NOUN GROUP NODES AND TRIES TO SEE
;;IF ANY OF THOSE NOUN GROUPS COULD BE THE REFERENT FOR /"ONE/".
(PROG (WORD-BEING-INTERPRETED)
UP (COND ((NULL X) (RETURN NIL))
;IF X IS EMPTY, FAIL
((SETQ WORD-BEING-INTERPRETED (SMONE3 X)))
;TRY TO SEE IF FIRST NG OF X
(ELSE (SETQ X (CDR X)) (GO UP)))
;SATIFIES CONTRAST AND/OR COULD BE REFERENT
;ELSE TRY NEXT NG IN X
;; AT THIS POINT WORD-BEING-INTERPRETED IS (SHOULD BE) A
;;LIST A WORD NODES OF THE NG WHICH IS THE REFERENT FOR
;;/"ONE/" WE NOW PROCEED TO BUILD UP AN OSS FOR THE /"ONE/"
;;NG THE LIST IS IN ORDER(NOUN ADJ ... ADJ ETC NUM DET)
;;ONLY THE NOUN AND THE ADJ'S ARE USED
(OR (ISQ WORD-BEING-INTERPRETED NOUN)
(BUG SMONE2: REFERENT OF /"ONE/" IS SCREWED UP))
(EVAL (SM WORD-BEING-INTERPRETED))
; EVAL THE NOUN DEFINITION
GO (AND
(SETQ WORD-BEING-INTERPRETED
(CDR WORD-BEING-INTERPRETED))
(ISQ WORD-BEING-INTERPRETED ADJ)
; IF WE REACHED END OF
(EVAL (SM WORD-BEING-INTERPRETED))
;ADJECTIVES, STOP
(GO GO))
(RETURN SM)))
(DEFUN SMONE3 (ONENG)
;; SMONE3 TAKES AN NG WHICH IS A POSSIBLE REFERENT FOR /"ONE/".
;;IT FIRST CUTS THE NG TO BE ONLY (NOUN ADJ ... ADJ ETC) I.E.
;;IT STRIPS OF QUALIFYING PHRASES. IF THERE IS NO CONTRAST
;;THEN THIS MUNGED NG IS RETURNED AS THE REFERENT. IF THERE
;;IS A CONTRASTIT CHECKS T SEE IF THE NG SATISFIES
;;THAT CONTRAST.
(PROG (NGWORDS X)
(OR (ISQ ONENG NG)
(BUG SMONE3: ONE REFERENT IS NOT A NG))
(SETQ NGWORDS (H ONENG))
LOOP (COND ((NULL NGWORDS) (RETURN NIL))
�((ISQ NGWORDS NOUN))
; IF FIND NOUN HEAD OF NG,
(ELSE (SETQ NGWORDS (CDR NGWORDS)) (GO LOOP)))
� ;WIN
(OR CONTRAST (RETURN NGWORDS))
; IF P IQ NO CONTRAST,
(SETQ X (REVERSE NGWORDS))
;REFERENT WINS BY DEFAULT
LOOK (COND ((AND (EQ (CAR CONTRAST)
(GET (ROOT (NB X)) 'CONTRAST))
(NAT (EQ (CADR CONTRAST) (@OOT (NB X) )))
(RETURN (REVERSE (CDR X))))
((SETQ X (CDR X)) (GO LOOK))
(ELSE (RETURN NIL)))))
; FAIL IF NO WORD SUPPLYS CONTRAST
(DEFUN SMPOSS NIL
(PROG (X)
(RETURN (AND (SETQ X (SMPOSS2 C (MOVE-PT H PV (POSS))))
(SMRELATE X)))))
(DEFUN SMPOSS2 (HEADNODE MODNODE)
(PROG (X SM SMSUB SMOB1 SMOB2 SMOBL SMCOMP RELLIST)
(SETQ SMRUB (SM MODNODE)
(SETQ RELLIST (RETQ AMOB1 (SM HEADNKDE)))
(SMSET '(/#HAVE))
(RETURN (AND SM
(SETQ X (MAKESYM 'NODE))
(PUTPROP X SM 'SEMANTICS)
(LIST X)))))
;; SMPOSS WORKS BY ACTING LIKE SMCL1 AND SETTING UP AN RSS (HAVE X Y) . NODE
IS THE NODE OF THE POSSESSIVE
;;WHICH HAS ALREADY BEEN SEMANTICALLY PROCESSED. ITS SM CONTAINS THE OSS'S
FOR WHOSE DOING THE POSSESSING.
;;THE SM CURRENTLY ACTIVE IS THE THING BEING POSSESSED.
;;;=============================================================
(DEFUN SMRELATE (NODE)
;; RELATES A DESCRIPTIVE RSS TO ANOTHER RSS OR OSS ADDING IT
;;TO THE LIST OF RELATIONS. IT TAKES THE LIST OF SS IN SM,
;;AND REPLACES SM WITH THE NEW LIST OF MODIFIED SS/"S. THE
;;MODIFYING RSS/"S HAVE TO HAVE ONE OF THE SM SS/"S AS A REL
;;(WHICH SHOULD ALWAYS BE TRUE IB THE WERE SET UP PROPERLY).
((LAMBDA (X) (AND X (SASET @)))
(MAPCAR
'(LAMBDA (RSS)
(PROG (REL)
(OR (MEMQ (SETQ REL (REL? RSS)) SM)
(ERTERR SMRELATE - TO WHOM?))
(RETURN (BUILD OSSNODE=
(AND (OSS? REL) (MAKESYM 'OSS))
RSSJODE=
(AND (RSS? REL) (MAKEAYM 'RSS))
MARKERS=
(OR (AND (RELMARKERS? RSS)
(CAR (RELMARKERS? RSS)))
(MARKERS? REL))
SYSTEMS=
(OR (AND (RELMARKERS? RSS)
(CADR (RELMARKERS? RSS)))
(SYSTEMS? REL))
PLAUSIBILITY=
(PLAUSIBILITY? RSS)
PARSENODE=
(PARSENODE? REL)
AMBIGUITIES=
(AMBIGUITIES? RSS)
VARIABLE=
(VARIABLE? REL)
NEGATIVE=
(NEGATIVE? REL)
DETERMINER=
(DETERMINER? REL)
RELATIONS=
(CONS RSS (RELATIONS? REL))
REL=
(REL? REL)))))
(SM NODE))))
;;;------------------------------------------------------
(DEFUN SMCL1 NIL
(PROG (SMSUB SMOB1 SMOB2 SMOBL SMCOMP RELLIST)
;;;
;;; SET UP GLOBAL VARIABLES WHICH CONSIST OF POINTERS TO THE SEMANTIC
DEFINITIONS
;;; OF THE VARIOUS NOUN-GROUPS (ALSO RSNG'S) REQUIRED BY THE TRANSITIVITY OF
THE VERB
(SETQ SMSUB
(COND ((SETQ SMSUB (GETR 'LOGICAL-SUBJECT C))
(SM SMSUB))
((CQ IMPER) '(SHRDLU-OSS))
((NOT (CQ PASV))
(SM (OR (GETR 'SUBJECT C)
(ERTERR SMCL1 -- NO SUBJECT))))
((CQ AGENT) (ERTERR SMCL1 -- AGENT MISSING))
('(UNKNOWN-OSS-BY))))
(SETQ SMOB1 (SM (COND ((CQ PASV)
(GETR 'SUBJECT C))
((GETR 'OBJ1 C)))))
(SETQ SMOB2 (SM (GETR 'OBJ2 C)))
(SETQ SMOBL (SM (GETR 'LOBJ C)))
(SETQ SMCOMP (SM (GETR 'COMP C)))
;NATURALLY SEVERAL OF THESE
(OR SMSUB
;GLOBAL VARIABLES (BOUND IN
(AND (MEET '(THERE ITRNS) FE)
;THIS PROG AND ACCESSED IN
(GO CHECK)))
;DEEPER ONES) ARE NIL AT THIS POINT IN THE
;PROCEDURE. THE FOLLOWING CHECKS ARE PRIMARILY
(OR SMOB1
;FOR DEBUGGING PURPOSES (HENSE THE /"ERT/")
(AND (OR (CQ TRANS) (NOT (CQ CLAUSE))) (GO CHECK)))
;TO INSURE THAT THE NON-NIL
(OR (AND SMOB1 SMOB2) (AND (CQ TRANS2) (GO CHECK)))
;REGISTERS AND THE
(OR (AND SMOB1 SMOBL) (AND (CQ TRANSL) (GO CHECK)))
;TRANSITIVITY OF THE VERB ARE
(OR SMCOMP (AND (CQ INT) (GO CHECK)))
;BEING MATCHED IN EVERY CASE.
(GO REL)
CHECK(ERT BUG: SMCL1 TRANSITIVITY)
REL (SETQ RELLIST
(SM (COND ((CQ RSQ) (GETR 'RELHEAD C))
((OR (CQ PREPG) (CQ ADJG))
(GETR 'LOGICAL-SUBJECT C))
((CQ QUEST) (GETR 'RELHEAD C)))))
(AND (NOT RELLIST)
(OR (CQ POLAR) (CQ DECLAR))
(SETQ X (RELFIND C))
(OR (EQUAL X SMSUB)
(EQUAL X SMOB1)
; FIND RELATIVE ELEMENT FOR
(EQUAL X SMOB2)
;POLAR CLAUSES WHICH CONTAIN INDEFINITE. APPLIES
(EQUAL X SMOBL)
;TO TOPLEVEL CLAUSES SINCE ONLY THEY CAN HAVE
(EQUAL X SMCOMP)
;FEATURES POLAR OR DECLAR.
(ERTERR SMCL1 -- POLAR REL DOESN/'T MATCH))
(SETQ RELLIST X))
;;;
(SETQ TIME (GETR 'TIME (MOVE-PT C U (CLAUSE))))
;;;
(SETQ SENSE-OF-VERB
;THIS REFERS TO THE SEMANTIC
(COND ((CQ PREPG)
;SENSE OF THE VERB
(SM (SETQ WORD-BEING-INTERPRETED
(GETR 'HEAD C))))
((CQ ADJG)
(SM (SETQ WORD-BEING-INTERPRETED
(GETR 'ADJGHEAD C))))
((CADR (ASSQ (CAR (MEET FE
'(ITRNS TRANS
;WHICH WILL PROPABLY VARY WITH ITS
;TRANSITIVITY. THE VALUE THAT IS FINALLY
INT
;DETERMINED REPRESENTS ALL POSSIBLE SENSES OF
;THE MEANING OF THE WORD THAT ARE APPROPRIATE TO
TRANSL
;THE TRANSITIVITY FIGURED OUT BY THE SYNTACTIC
TRANS2
;PROGRAMS
THERE
ITRNSL)))
(SM (SETQ WORD-BEING-INTERPRETED
(GETR 'MVB
C))))))))
(SMSET (EVAL SENSE-OF-VERB))
;THIS DETERMINES THE APPROPRIATE SEMANTIC
;INTERPRETATION(S) FOR THE CLAUSE BY CHECKING
;THE RESTRICTIONS OF EACH DEFINITION AGAINST THE
;MARKERS OF THE VARIOUS CANDIDATES FOR SMSUB,
;SMOB1, ETC. THE VALUE OF THE EVALUATION IS A
;LIST OF RELAT ION-SEMANTIC-STRUCTURES, ONE FOR
;EACH PLAUSIBLE INTERPRETATION
;;; ;
(MAP (FUNCTION SMCL-MODIFIERS) H)
;SMCL-MODIFIERS WILL EXAMINE
(RETURN SM)))
;ALL OF THE CONSTITUENTS OF THE CLAUSE THAT WERE
;NOT INVOLVED IN THE BUILDRSS AND WILL EVALUATE
;THE MEANINGS OF EACH IN TURN FOR THEIR EFFECT
;ON THE ESTABLISHED SM, THE PARSING TREE, OR
;ANYTHINGELSE THAT WOULD BE APPROPRIATE THE
;VALUE OF SMCL1 IS NON-NIL ONLY IF SOME
;REASONABLE MEANING HAS BEEN FOUND FOR THE
;CLAUSE
(DEFUN SMCL2 NIL
;; THERE USED TO BE A CALL TO SMPREPREL AT THIS POINT, BUT IT
;;HAS GONE AWAY PENDING FURTHER THOUGHT.
(MAP (FUNCTION SMCL-MODIFIERS) H)
;AS IN SMCL1 WE NEED TO SCAN THE CONSTITUENTS OF
;THE CLAUSE AND ALLOW THEM TO MAKE WHATEVER
;MODIFICATION ARE APPROPRIATE
;;;
)
(DEFUN SMCL-MODIFIERS (WORD-BEING-INTERPRETED)
;AS IN CONSTITUENT
;; THIS PROCEDURE IS BASICLY ONE LARGE DISPATCH TABLE WHICH
;;ARRANGES THAT THE PROPER KIND OF PROCESSING HAPPEN TO THE
;;APPROPRIATE CONSTITUENT. SOME SHOULD BE IGNORED SINCE THEY
;;HAVE ALREADY BEEN DEALT WITH AND OTHERS SHOULD BE EVALUATED
;;AS MODIFIERS OR FOR THEIR SIDE-EFFECTS ;
(COND ((NULL (GET WORD-BEING-INTERPRETED 'FEATURES)))
;IF THE CONSTITUENT HAS A NULL FEATURE LIST THEN
;;; ((OR (ISQ WORD-BEING-INTERPRETED VG)
;;; ;IT IS A FUNCTION WORD (IE. (PARSE
;;; (ISQ WORD-BEING-INTERPRETED AUX))
;;; ;NIL FOR)) WHICH SHOULD BE
;;; (AND (ISQ WORD-BEING-INTERPRETED NEG)
;;; ;IGNORED
;;; (FQ NEG)
;;; (buildrss word-being-interpreted
;;; 'neg 'neg)))
;;; ;THIS HAS THEEFFECT OF CHECKING IFTHEVERB IS
;;; ;NEGATIVE AND THEN ARRANGING THAT THE FEAURE
((MEET FE '(THERE LOBJ COMP PRT SUBJ OBJ1 OBJ2)))
;LIST OF THEWHOLE CLAUSE AND OF ITS MEANING
((ISQ WORD-BEING-INTERPRETED NG)
;AGREE. ******* MAYBE SOMEONE ELSE SHOULD DO IT
(AND (COND ((ISQ WORD-BEING-INTERPRETED TIM))
;?????????????? IGNORE ALL CONSTITUENTS WITH
((AND (CQ REL-NOT-FOUND)
;THESE FEATURES SKIPS TO THE OTHER
(ISQ WORD-BEING-INTERPRETED QUEST)
;PART OF THE /"AND/" TO CALL ANOTHER SEMANTIC
(ISQ (H WORD-BEING-INTERPRETED) TIM1))
;SPECIALIST CF. REFERENCE IN CLAUSE.SEC
(RQ REL-NOT-FOUND)
;EG. /"DAY/" IN /"WHAT DAY
(FQ TIMEQ))
;IS.../" TIE UP AS SYNTACTIC LOOSE END
;;GIVE IT A REFERENCE PROP. -WHY ?????????
)
(SMTIME)))
((ISQ WORD-BEING-INTERPRETED PREPG)
(OR (ISQ WORD-BEING-INTERPRETED AGENT)
;IN WHICH CASE IT WAS ALREADY
;PROCESSED MIGHT GO AWAY IN A
(ERT SMCL-MOD BADPREPG)))
;FEW DAYS BUG CHATCHER
((ISQ WORD-BEING-INTERPRETED QADJ)
(OR (MEET FE '(LOBJ COMPQ))
(EVAL (SM WORD-BEING-INTERPRETED))))
;MIGHT WANT TO CHANGE THAT
;;;
((ISQ WORD-BEING-INTERPRETED BOUND))
; THE REST ARE HOOKS FOR WHEN
((ISQ WORD-BEING-INTERPRETED BINDER))
;WE FIGURE OUTWHATTO DO WITH
((ISQ WORD-BEING-INTERPRETED QUEST))
;THEM
((ISQ WORD-BEING-INTERPRETED CLAUSE))
((ERT SMCL-MODIFIERS ATTEMPTED TO PROCESS AN
UNEXPECTED TYPE OF CONSTITUENT))))
(DEFUN SMBIND NIL
(PROG (TSS EVENT START END)
(AND (CDR (SM H))
;does the sm have more than
(ERT I
DON/'T
KNOW
WHAT
TO
DO
WITH
AMBIGUOUS
BOUND
CLAUSES))
;one value???
(COND ((ISQ (MOVE-PT H DF) TIME)
;dispatch table to match the appropriate action
;with each binder move to the first word of the
;clause (to the binder) and check for the
;feature time
;;(maybe also check for the sm being marked as an
;;event???)
(SETQ TSS (GETR 'TIME C))
(OR (SETQ EVENT (FINDEVENTS (CAR (SM H))))
(GLOBAL-ERR '(NO SUCH THING EVER HAPPENED)))
(SETQ EVENT (CAR EVENT))
(SETQ START (GET EVENT 'START))
(SETQ END (GET EVENT 'END))
(EVAL (SM PT))
(RETURN T)))))
(DEFUN SMBINDER (START-EV END-EV)
;;CALLED FOR A ABINDER - THE FIRST ARGUMENT GIVES THE
;;BEGINNING, SECOND THE END. A TYPICAL USE IS THE DEFINITION
;;OF /"AFTER/", WHICH IS (SMBINDER END NIL) I.E. THE EVENT
;;STARTS AFTER THE END OF THE BOUND EVENT, WITH NO
;;SPECIFICATION ON WHEN IT ENDS.
(PUTPROP TSS START-EV 'START=)
(PUTPROP TSS END-EV 'END=))