;;;; Hey, emacs(1), this is -*- Mode: tdl; Coding: utf-8; -*- got it?


;;;;
;;;; a `new' (sort of, we had experimented with it a bit in LOGON) mechanism to
;;;; improve generator robustness (and possibly efficiency; berthold lobbied
;;;; for that :-).  generator inputs are subjected to a transfer grammar prior
;;;; to generation proper; there must not be transfer ambiguity for this to
;;;; work.  --- an initial set of rules is taken from the LOGON fix-up phase.
;;;;

;;;;;;;;;;;;;;;;;;
;;; Mark gaps  ;;;
;;;;;;;;;;;;;;;;;;



#|
gap_gr  := monotonic_mtr &
		 [ FILTER.RELS <! [PRED "gap_mark",
				   ARG1 #x]
				!>, 
		   CONTEXT.RELS <! 
				 [PRED "focus_d_rel",
				  ARG2 #x], 
				 [ARG0 #x]
			    !>,		  
		   OUTPUT.RELS <! [PRED "gap_mark",
				   ARG0 [--GAP +],
				   ARG1 #x] !>].

rel_gap_gr  := monotonic_mtr &
		 [ FILTER.RELS <! [PRED "gap_mark",
				   ARG1 #x]
				!>, 
		   CONTEXT.RELS <! 
				 [PRED "topic_d_rel",
				  LBL #h,
				  ARG2 #x], 
				 [LBL #h,
				  ARG0 #x]
			    !>,		  
		   OUTPUT.RELS <! [PRED "gap_mark",
				   ARG0 [--GAP +],
				   ARG1 #x] !>].


gap_unify_gr := 
		monotonic_mtr & 
		[INPUT.RELS <! [PRED "gap_mark",
				ARG0 [--GAP +],
				ARG1 [--GAP -]] !>,
		 OUTPUT.RELS <! +copy+ & [PRED "gap_mark",
					  ARG1 [--GAP +]] !> ].

gap_mark_ditch_gr := 
		     monotonic_mtr & 
		     [INPUT.RELS <! [PRED "gap_mark"] !>,
		      OUTPUT.RELS <!  !> ].

|#



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Mark extraction contexts ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

#|
xtr-_arg1_gr  := monotonic_mtr &
		 [ FILTER.RELS <! [PRED "xtr_mark",
				   ARG1 #e1,
				   ARG2 #x2,
				   ARG3 #ev]
				!>, 
		   CONTEXT.RELS <! 
				 [PRED "~_v_",
				  ARG0 #ev & event & [--XTR #xtr & - ],
				  ARG1 #x2],
				 [PRED "focus_d_rel",
				  ARG0 event,
				  ARG1 #e1,
				  ARG2 #x2], 
				 [ARG0 #x2 ]
			    !>,		  
		   OUTPUT.RELS <! [PRED "xtr_mark",
				   ARG0 [--XTR bool],
				   ARG1 #e1,
				   ARG2 #x2,
				   ARG3 #ev] !>,
		   FLAGS.EQUAL <#xtr>].

xtr-_arg2_gr  := monotonic_mtr &
		 [ FILTER.RELS <! [PRED "xtr_mark",
				   ARG1 #e1,
				   ARG2 #x2,
				   ARG3 #ev]
				!>, 
		   CONTEXT.RELS <! 
				 [PRED "~_v_",
				  ARG0 #ev & event & [--XTR #xtr & - ],
				  ARG2 #x2],
				 [PRED "focus_d_rel",
				  ARG0 event,
				  ARG1 #e1,
				  ARG2 #x2], 
				 [ARG0 #x2 ]
			    !>,		  
		   OUTPUT.RELS <! [PRED "xtr_mark",
				   ARG0 [--XTR +],
				   ARG1 #e1,
				   ARG2 #x2,
				   ARG3 #ev] !>,
		   FLAGS.EQUAL <#xtr>].


xtr-_arg3_gr  := monotonic_mtr &
		 [ FILTER.RELS <! [PRED "xtr_mark",
				   ARG0 [--XTR +],
				   ARG1 #e1,
				   ARG2 #x2,
				   ARG3 #ev]
				!>, 
		   CONTEXT.RELS <! 
				 [PRED "~_v_",
				  ARG0 #ev & event & [--XTR #xtr & - ],
				  ARG3 #x2],
				 [PRED "focus_d_rel",
				  ARG0 event,
				  ARG1 #e1,
				  ARG2 #x2], 
				 [ARG0 #x2 ]
			    !>,		  
		   OUTPUT.RELS <! [PRED "xtr_mark",
				   ARG0 [--XTR +],
				   ARG1 #e1,
				   ARG2 #x2,
				   ARG3 #ev] !>,
		   FLAGS.EQUAL <#xtr>].


;;; rel_xtr_mark records ARG1 and ARG2 of topic_d_rel as ARG1 and ARG2 
;;; ARG3 is the hypothesised gap site, ARG4 records events along the 
;;; extraction path. 

relxtr-_arg1_gr  := monotonic_mtr &
		 [ FILTER.RELS <! [PRED "rel_xtr_mark",
				   ARG0 [--XTR -],
				   ARG1 #e1 ,
				   ARG2 #x2,
				   ARG3 #ev]
				!>, 
		   CONTEXT.RELS <! 
				 [PRED "~_v_",
				  ARG0 #ev & event & [--XTR #xtr & - ],
				  ARG1 #x2 & ref-ind],
				 [PRED "topic_d_rel",
				  LBL #h1 & handle,
				  ARG0 event & [e no_tam],
				  ARG1 #e1,
				  ARG2 #x2], 
				 [LBL #h1,
				  ARG0 #x2 ]
				 !>,		  
		   OUTPUT.RELS <! [PRED "rel_xtr_mark",
				   ARG0 [--XTR -],
				   ARG1 #e1,
				   ARG2 #x2,
				   ARG3 #ev,
				   ARG4 #ev] !>,
		   FLAGS [EQUAL <#xtr>,
			  SUBSUME <#x2>]].


relxtr-_arg2_gr  := monotonic_mtr &
		 [ FILTER.RELS <! [PRED "rel_xtr_mark",
				   ARG0 [--XTR -],
				   ARG1 #e1 ,
				   ARG2 #x2,
				   ARG3 #ev]
				!>, 
		   CONTEXT.RELS <! 
				 [PRED "~_v_",
				  ARG0 #ev & event & [--XTR #xtr & - ],
				  ARG2 #x2 & ref-ind],
				 [PRED "topic_d_rel",
				  LBL #h1 & handle,
				  ARG0 event & [e no_tam],
				  ARG1 #e1,
				  ARG2 #x2], 
				 [LBL #h1,
				  ARG0 #x2 ]
				 !>,		  
		   OUTPUT.RELS <! [PRED "rel_xtr_mark",
				   ARG0 [--XTR -],
				   ARG1 #e1,
				   ARG2 #x2,
				   ARG3 #ev,
				   ARG4 #ev] !>,
		   FLAGS [EQUAL <#xtr>,
			  SUBSUME <#x2>]].

relxtr-_arg3_gr  := monotonic_mtr &
		    [ FILTER.RELS <! [PRED "rel_xtr_mark",
				      ARG0 [--XTR -],
				      ARG1 #e1 ,
				      ARG2 #x2,
				      ARG3 #ev]
				   !>, 
		      CONTEXT.RELS <! 
				    [PRED "~_v_",
				     ARG0 #ev & event & [--XTR #xtr & - ],
				     ARG3 #x2 & ref-ind],
				    [PRED "topic_d_rel",
				     LBL #h1 & handle,
				     ARG0 event & [e no_tam],
				     ARG1 #e1,
				     ARG2 #x2 ], 
				    [LBL #h1,
				     ARG0 #x2]
				    !>,		  
		      OUTPUT.RELS <! [PRED "rel_xtr_mark",
				      ARG0 [--XTR -],
				      ARG1 #e1,
				      ARG2 #x2,
				      ARG3 #ev,
				      ARG4 #ev] !>,
		      FLAGS [EQUAL <#xtr>,
			     SUBSUME <#x2>]].

relxtr+_gr  := monotonic_mtr &
		    [ INPUT.RELS <! [PRED "rel_xtr_mark",
				     ARG0 [--XTR - & #xtr],
				     ARG1 #ev,
				     ARG2 #x2,
				     ARG3 #ev,
				     ARG4 #ev
				     ] !>,
		      OUTPUT.RELS <! [PRED "rel_xtr_mark",
				      ARG0 [--XTR +],
				      ARG1 #ev,
				      ARG2 #x2,
				      ARG3 #ev,
				      ARG4 #ev] !>,
		      FLAGS.EQUAL <#xtr>].


relxtr-_recurse_arg1_gr  := monotonic_mtr &
		       [ FILTER.RELS <! [PRED "rel_xtr_mark",
					      ARG0 [--XTR -],
					      ARG1 #e1,
					      ARG2 #x2,
					      ARG3 #ev,
					      ARG4 #e1 ] !>,
			 INPUT.RELS <! [PRED "rel_xtr_mark",
					ARG0 #e0 & [--XTR -],
					ARG1 #e1,
					ARG2 #x2,
					ARG3 #ev,
					ARG4 #e4
					     ] !>,
			 CONTEXT.RELS <! 
				       [ARG0 #e5 & event,
					ARG1 #h & handle],
				       [LBL #h,
					ARG0 #e4 & event]
				       !>, 
			 OUTPUT.RELS <! 
				      [PRED "rel_xtr_mark",
				       ARG0 #e0 & [--XTR -],
				       ARG1 #e1,
				       ARG2 #x2,
				       ARG3 #ev,
				       ARG4 #e5] !>, 
			 FLAGS.SUBSUME <#h>].


relxtr-_recurse_arg2_gr  := monotonic_mtr &
			    [ FILTER.RELS <! [PRED "rel_xtr_mark",
					      ARG0 [--XTR -],
					      ARG1 #e1,
					      ARG2 #x2,
					      ARG3 #ev,
					      ARG4 #e1 ] !>,
			      INPUT.RELS <! [PRED "rel_xtr_mark",
					     ARG0 [--XTR -],
					     ARG1 #e1,
					     ARG2 #x2,
					     ARG3 #ev,
					     ARG4 #e4
						  ] !>,
			      CONTEXT.RELS <! [ARG0 #e5 & event ,
					       ARG2 #h & handle],
					    [LBL #h,
					     ARG0 #e4  & event ]
					    !>, 
			      OUTPUT.RELS <! [PRED "rel_xtr_mark",
					      ARG0 [--XTR -],
					      ARG1 #e1,
					      ARG2 #x2,
					      ARG3 #ev,
					      ARG4 #e5] !>, 
			      FLAGS.SUBSUME <#h>].

relxtr-_recurse_arg3_gr  := monotonic_mtr &
		       [ FILTER.RELS <! [PRED "rel_xtr_mark",
					 ARG0 [--XTR -],
					 ARG1 #e1,
					 ARG2 #x2,
					 ARG3 #ev,
					 ARG4 #e1 ] !>,
			 INPUT.RELS <! [PRED "rel_xtr_mark",
					ARG0 [--XTR -],
					ARG1 #e1,
					ARG2 #x2,
					ARG3 #ev,
					ARG4 #e4
					     ] !>,
			 CONTEXT.RELS <! [ARG0 #e5  & event,
					  ARG3 #h & handle],
				       [LBL #h,
					ARG0 #e4  & event]
				       !>, 
			 OUTPUT.RELS <! [PRED "rel_xtr_mark",
					 ARG0 [--XTR -],
					 ARG1 #e1,
					 ARG2 #x2,
					 ARG3 #ev,
					 ARG4 #e5] !>, 
			 FLAGS.SUBSUME <#h>].





xtr+_bool_unify_gr := 
			  monotonic_mtr & 
			  [INPUT.RELS <! [PRED "xtr_mark",
					  ARG0 [--XTR #xtr & bool],
					  ARG2 #x2,
					  ARG3 #ev & [--XTR -]] !>,
			   FLAGS.EQUAL <#xtr>,
			   OUTPUT.RELS <! +copy+ & [PRED "xtr_mark",
						    ARG0 [--XTR -],
						    ARG2 [--GAP +],
						    ARG3 [--XTR +]] !> ].



xtr-_mark_ditch_gr := 
		     monotonic_mtr & 
		     [INPUT.RELS <! [PRED "~(rel_)?xtr_mark",
				     ARG0 [--XTR #xtr & -]] !>,
		      FLAGS.EQUAL <#xtr>,
		      OUTPUT.RELS <!  !> ].


xtr+_unify_gr := 
			  monotonic_mtr & 
			  [INPUT.RELS <! [PRED "xtr_mark",
					  ARG0 [--XTR +],
					  ARG2 #x2,
					  ARG3 #ev & [--XTR -]] !>,
			   OUTPUT.RELS <! +copy+ & [PRED "xtr_mark",
						    ARG2 [--GAP +],
						    ARG3 [--XTR +]] !> ].

rel_xtr+_unify_gr := 
			  monotonic_mtr & 
			  [INPUT.RELS <! [PRED "rel_xtr_mark",
					  ARG0 [--XTR +],
					  ARG3 [--XTR -]] !>,
			   OUTPUT.RELS <! +copy+ & [PRED "rel_xtr_mark",
						    ARG2 [--GAP +],
						    ARG3 [--XTR +]] !> ].

xtr_mark_ditch_gr := 
		     monotonic_mtr & 
		     [INPUT.RELS <! [PRED "~(rel_)?xtr_mark"] !>,
		      OUTPUT.RELS <!  !> ].
|#