;;; -*- Mode: TDL; Coding: utf-8 -*- 

;;; Authors: 
;;; 1997-2000 Walter Kasper & Stefan Müller
;;; 2000-2002 Stefan Müller
;;; 2002-2006 Berthold Crysmann

;;; Copyright: DFKI GmbH





det-nbar := det-n1-head-rule-type.


np-nbar := np-n1-head-rule-type.



empty-noun-modifier-rule :=
  empty-noun-modifier-rule-type &
  [
    synsem fak-intr-det-ref-comp-nominal-synsem-syn & [ 
           loc [ cat [ head #head & [
                            cas #cas,
                            lpe #lpe
                            ],
                       inflected #inflected, 
                       spr  < #det & det-synsem & [
                                     loc.CONT.KEY [ ARG0 #index ]
                                     ]
                            >,
                       no_adj #no_adj
                     ],
                  cont.HOOK.INDEX #index,
                  coord -,
                 uniagr #uniagr
               ],
            cat-change +,
            lex -,
            phrase #phrase
           ],
  ARGS <
         [ 
           synsem complete-noun-modifier-synsem &
                  [ loc [cat [ head [ mod noun-synsem & [
                                         loc.cat [ head #head & [ 
                                                         cas #cas
                                                         ],
                                                   spr < #det >
                                                 ]
                                         ],
                                     lpe #lpe
                                   ],
                              inflected #inflected,
                              no_adj #no_adj
                            ],
                         uniagr #uniagr],
                    phrase #phrase
                  ],
           key-arg +
         ]
       >
  ].


rel-clause-proj :=
               rs-proj-rule-type & 
               [synsem complete-synsem & 
                       [loc [ cat.head #rp-head,
                              coord -
                                       ],
                        cat-change -,
                        lex -
                            ],
                ARGS <[synsem complete-noun-modifier-synsem &
                              [ loc [cat.head rel-clause-head & [
				 rp-head #rp-head]]],
                        key-arg +
                              ]
                      >
                       ].


empty-det-sg :=
  empty-det-rule-type &
  [
 ARGS < [ synsem.loc [ cat.spr < [ loc.cat.drop-det + ] >,
                        uniagr c-s-g
                                ]
                      ]
         
        >
].

empty-det-pl :=
  empty-det-rule-type &
  [
  ARGS < [ synsem.loc.uniagr c-p-g ]>
].



n-mod-gen-np :=
  n-mod-gen-np-rule-type &

  [
    synsem noun-synsem & [ 
             loc [ cat [ spr    #spr,
                         subcat #sc,
                         vcomp  <>
                       ],
                   coord -
                 ],
             lex -,
             phrase +
           ],
    C-CONT [ RELS <! poss-rel &
		   [ LBL #hand,
			ARG0 event,
                        ARG1 #possr,
                        ARG2 #possd ] !>,
             HCONS <! !> ],
  ARGS <
         [
           synsem noun-synsem & [ 
                    loc [ cat [ spr    #spr & < synsem >,
                                subcat #sc,
                                vcomp  <>
                              ],
                          CONT [ hook [ltop #hand,
				       INDEX #possr] ]
                        ],
                    lex +
                   ]
         ],
         [
           synsem complete-comp-noun-synsem & 
                  [ loc [ 
                          CONT [ hook [INDEX #possd] ],
                          uniagr g-n-g
                        ],
                    lex    -
                  ],
           key-arg +
         ]
       >
  ].

;; Irans Außenminister
np-to-det := np-to-det-rule-type.


h-subj := h-s-rule-type.
subj-h := s-h-rule-type.

h-comp := h-c-rule-type & [head-dtr.synsem.loc.coord bool,
			     non-head-dtr.synsem.loc.sgf sgf-lee- ].

coord-comp-non-v := h-c-rule-type & [synsem.loc [coord na,
					     uniagr._cas <#c . case-list>],
				 head-dtr.synsem.loc [cat.head coord-head],
				     non-head-dtr.synsem.loc [cat.head non-verbal-head,
							      uniagr #c ]].


coord-comp-fin := h-c-rule-type & [synsem.loc [coord na,
					     uniagr._cas <#c . case-list>],
				 head-dtr.synsem.loc [cat.head coord-head,
						      cont.hook.index event],
				 non-head-dtr.synsem.loc [cat.head [vform fin-sm],
							  uniagr #c ]].



coord-comp-nonfin := h-c-rule-type & 
		  [synsem.loc [coord na,
			       uniagr._cas <#c . case-list>],
		   head-dtr.synsem.loc [cat.head coord-head 
						 & [spec [loc.cont.hook.index event &
									      [e [tense #t,
										  mood #m] ]]],
					cont.hook.index event & 
						 [e [tense #t,
						     mood #m
							   ]]],
		   head-dtr.synsem.loc.cat.head coord-head,
		   non-head-dtr.synsem.loc [cat.head.vform non-fin-sm,
					    uniagr #c, 
					    cont.hook.index event & 
							   [e [tense #t,
							       mood #m
								     ]]]].




comp-h := c-h-rule-type.




h-subj-extraposed := h-extra-s-rule-type & [non-head-dtr.key-arg +].
h-comp-extraposed := h-extra-c-rule-type & [non-head-dtr.key-arg +].


h-adjunct-extraposed := 
                    h-extra-a-rule-type & [non-head-dtr.key-arg +].


vcomp-h-0 := vc-head-rule & 
                         [synsem.loc.cat.subcat.list #sc,
                          head-dtr [synsem.loc.cat [subcat.list <>,
                                                 vcomp <[loc.cat.subcat.list #sc]>]]].

vcomp-h-1 := vc-head-rule & 
                         [synsem.loc.cat.subcat.list <#1 . #sc>,
                          head-dtr [synsem.loc.cat [subcat.list <#1>,
                                                 vcomp <[loc.cat.subcat.list #sc]>]]].

vcomp-h-2 := vc-head-rule & 
                         [synsem.loc.cat.subcat.list <#1,#2 . #sc>,
                          head-dtr [synsem.loc.cat [subcat.list <#2>,
                                                 vcomp <[loc.cat.subcat.list <#1 .#sc>]>]]].


vcomp-h-3 := vc-head-rule & 
                         [synsem.loc.cat.subcat.list <#1,#2,#3 . #sc>,
                          head-dtr [synsem.loc.cat [subcat.list <#3>,
                                                 vcomp <[loc.cat.subcat.list <#1,#2 .#sc>]>]]].

vcomp-h-4 := vc-head-rule & 
                         [synsem.loc.cat.subcat.list <#1,#2,#3,#4 . #sc>,
                          head-dtr [synsem.loc.cat [subcat.list <#4>,
                                                 vcomp <[loc.cat.subcat.list <#1,#2,#3 .#sc>]>]]].



h-adjunct :=  h-a-rule-type.

                           
adjunct-h :=  a-h-rule-type.


subj-slash-intro :=
			subj-slash-intro-rule .

comp-slash-intro :=
			comp-slash-intro-rule .


adj-slash-intro-vfin :=
                       adj-slash-intro-rule-final.

adj-slash-intro-vini :=
                       adj-slash-intro-rule-initial.



filler-h :=
  no-nonloc-headed-binary-rule-type & [
  synsem complete-comp-fin-verb-synsem & [
           loc [ cat   #mom-cat,
                 coord -,
                 adjunction unmodifiable,
                 CONT.MESSAGE #mess,
                 sgf [lor #lor,
		      lee <>],
		 anc anc-inher & [active  <! !>,
				  inert <! !>,
				  self  <! !>] 
		       ],
           lex -,
           phrase +,
           v2     +
          ],
  head-dtr #hd,
  non-head-dtr #nhd & [synsem.que [list #l,
				   last #l & *null*]],
  ARGS < #nhd &  
	 [synsem 
		 [loc    #filler-local & 
			 [ cat.head #f-hd & no-eps-head,
			   CONT #f-cont & [MESSAGE #mess],
			   anc anc-inher ],
		  nonloc undef-nonlocs   
			 ]],
	 #hd &  
	 [synsem saturated-comp-fin-verb-synsem & 
		 [ loc [cat #mom-cat & 
			    [head initial_+_fin-verb-head
				  ],
			sgf.lor #lor  ],
		   nonloc contains-slash & 
		       [_slash <! [cat.head #f-hd,
				   cont #f-cont ] !>,
			slash.LIST.FIRST #filler-local
					 ],
		   lex -,
		   v2  -
		       ],
	  key-arg + 
		 ]
	 >
  ].


wh-h :=
  wh-no-nonloc-headed-binary-rule-type & [
  synsem complete-comp-fin-verb-synsem & [
           loc [ cat   #mom-cat,
                 coord -,
                 adjunction unmodifiable,
                 sgf [lor #lor,
		      lee <>],
		 anc anc-inher & [active  <! !>,
				  inert <! !>,
				  self  <! !>] 
		       ],
           lex -,
           phrase +,
           v2     +
          ],
  head-dtr #hd,
  non-head-dtr #nhd,
  ARGS < #nhd &  
	 [key-arg + ,
	  synsem 
		  [loc    #filler-local & 
			  [cat.head #f-hd & no-eps-head,
			   cont #f-cont,
			   anc anc-inher ],
		  nonloc undef-nonlocs   
			 ]],
	 #hd &  
	 [synsem saturated-comp-fin-verb-synsem & 
		 [ loc [cat #mom-cat & 
			    [head initial_+_fin-verb-head
				  ],
			sgf.lor #lor],
		   nonloc contains-slash & 
		       [_slash <! [cat.head #f-hd,
				   cont #f-cont ] !>,
			slash <! #filler-local !>
					 ],
		   lex -,
		   v2  -
		       ]
		 ]
	 >
  ].



rel-clause := extraction-rel-clause-rule-type.


int-clause := extraction-int-clause-rule-type.



coord :=
	     coordination-rule-type & 
	     [synsem [ loc [ cat #cat,
			     cont [key #key,
				   hook [ltop #l,
					 index #index]],
			     adjunction #adj,
			     coord +,
			     sgf [lor <>],
			     uniagr._cas <#conj-agr . #rest-agr>
				 ],
		       nonloc #nonloc,
		       que     #que,
		       v2 #v2
			   ],
	      c-cont [rels <! !>,
		      hcons <! !>],
	      ARGS <
			   [
         synsem #spec & [ 
                  loc [cat #cat,
                       adjunction #adj,
		       uniagr #conj-agr 
			   ],
                  nonloc  #nonloc,
                  que     #que,
                  v2      #v2
                ]
         ],
         [
           synsem saturated-synsem & 
           [ loc [ cat [ head coord-head & 
                              [ spec #spec,
                                coordform normal-coord
                                     ]
                              ],
		   cont [key #key,
			 hook [index #index,
			       ltop #l]],
		   uniagr._cas #rest-agr
                       ]
                 ],
          key-arg +
           ]
        >
  ].





binary-coord :=
		    coordination-rule-type & 
		    [synsem [ loc [ cat #cat,
				    adjunction #adj,
				    coord -,
				    cont [key #key,
					  hook [index #ki,
						ltop #kl]],
				    sgf  sgf-lor-lee-,
				    uniagr._cas <#conj-agr . #rest-agr>
					], 
			      nonloc  #nonloc ,
			      que #que,
			      v2    #v2
				  ],
		     c-cont [rels <! !>,
			     hcons <! !>],
		     ARGS <
			   [synsem saturated-synsem & 
				   [loc [ cat [ head coord-head & 
						     [spec [ loc [cat #cat,
								  cont [hook [index #i,
									      ltop #l]],
								  adjunction #adj,
								  sgf  sgf-lee-],
							     nonloc #nonloc,
							     v2      #v2
								 ],
						      coordform  initial-binary-coord
							   ]
						     ],
					  cont [hook [ltop #kl,
						      index #ki],
						key #key & [pred #keypred]],
					  uniagr._cas <#conj-agr, ...>
					      ],
				    que #que
					],
			    key-arg +
				   ],
			   [synsem saturated-synsem & 
				   [loc [ cat [ head coord-head & 
						     [spec [ loc [cat #cat,
								  cont.key.pred #keypred,
								  adjunction #adj,
								  sgf sgf-lee-],
							     nonloc  #nonloc,
							     v2      #v2
								 ],
						      coordform  final-binary-coord
							   ]
						     ],
					  cont [hook [index #i,
						      ltop #l]],
					  uniagr._cas #rest-agr
					      ],
				    que #que
					]
				   ]
			   >
			    ].




recursive-ev-coord :=
  temp-coordination-rule-type & [ 
  synsem [ loc [ cat #cat,
                 cont [hook [index #i,
			     ltop #lbl],
		       key #key],
		 adjunction #adj,
                 coord #coord,
                 sgf sgf-lor-lee- 
               ],  
	   nonloc  #nonloc,
           v2 #v2
         ],
  c-cont [rels <! #key & [lbl #lbl,
			  pred "implicit_coord_rel",
			  arg0 #i & event,
			  l-index #lind & event,
			  r-index #rind  & event,
			  l-hndl #lh,
			  r-hndl #rh
		   ] !>,
	  hcons <! !>],
  ARGS <
         [
         synsem [ loc [cat #cat,
		       cont [hook [index #lind,
				   ltop #lh]],
                       adjunction #adj,
                       sgf sgf-lee-],
                  nonloc  #nonloc,
                  v2      #v2
                ]
         ],
         [
           synsem saturated-synsem & [ 
                  loc [ cat #cat,
			cont [hook [index #rind,
				    ltop #rh]],
                        adjunction #adj,
                        sgf sgf-lee-,
                        coord #coord & +
                      ],
                  nonloc #nonloc,
                  v2      #v2,
                  phrase  +
                  ],
          key-arg +
         ]
        >
  ].

recursive-nom-coord :=
  temp-coordination-rule-type & [ 
  synsem [ loc [ cat #cat,
                 cont [hook [index #i],
		       key #key],
		 adjunction #adj,
                 coord #coord,
                 sgf sgf-lor-lee-,
		 uniagr._cas <#conj-agr . #rest-agr>
               ],  
	   nonloc  #nonloc,
           v2 #v2
         ],
  c-cont [rels <! udef_rel & [pred "udef_q_rel",
			      arg0 #i,
			      rstr #harg], #key & [lbl #lbl,
			  pred "implicit_coord_rel",
			  arg0 #i & index,
			  l-index #lind & index,
			  r-index #rind  & index
			       ] !>,
	  hcons <! qeq & [harg #harg,
			  larg #lbl] !>],
  ARGS <[synsem [ loc [cat #cat,
		       cont [hook [index #lind]],
                       adjunction #adj,
                       sgf sgf-lee-,
		       uniagr #conj-agr],
                  nonloc  #nonloc,
                  v2      #v2
                ]
         ],
         [
           synsem saturated-synsem & [ 
                  loc [ cat #cat,
			cont [hook [index #rind]],
                        adjunction #adj,
                        sgf sgf-lee-,
                        coord #coord & +,
			uniagr._cas #rest-agr
                      ],
                  nonloc #nonloc,
                  v2      #v2,
                  phrase  +
                  ],
          key-arg +
         ]
        >
  ].

 



pos-es :=
	 pos-es.



clause-proj :=
		   inher-nonloc-unheaded-unary-rule  & [
  synsem v2-comp-synsem & [
	 loc [cat.head.extra na_or_+,
	      sgf sgf-lor-lee-,
	      anc anc-inher & [self <! !>,
			       active <! !>,
			       inert <! !>],
	      cont mrs & [MESSAGE #key & [pred message_m_rel,
					  LBL #lbl],
			  RELS #rels,
			  HOOK [ltop #lbl],
			  HCONS [LIST  #s-hcons,  
				 LAST #hc-last]
                  ],
	      adjunction unmodifiable],
          cat-change +,
          ellipse    #ellipse 
          ],
  ARGS < [ synsem complete-s-v2-synsem &
                  [ LOC [sgf sgf-lee-,
                         CONT [hook [ltop #lbl],
			       MESSAGE #key, 
                               RELS #rels,
                               HCONS [LIST  #s-hcons,
				      LAST #hc-last]
                             ]] ,
                    ellipse #ellipse
                  ]
         ] 
       >
  ].





eps-vcomp-3:= eps-vc-rule-1+ & 
	      [synsem.loc.cat [head [v1.cat [subcat.list <#3 >]],
                                 subcat.list <#1,#2,#3  . #sc>],
                  args <[synsem.loc.cat.subcat.list <#1,#2 . #sc>]>].

eps-vcomp-2:= eps-vc-rule-1+ & 
                [synsem.loc.cat [head [v1.cat [subcat.list <#2 >]],
				 subcat.list <#1,#2   . #sc>],
                  args <[synsem.loc.cat.subcat.list <#1 . #sc>]>].

eps-vcomp-1:= eps-vc-rule-1+ & 
                [synsem.loc.cat [head [v1.cat [subcat.list <#1>]],
                                 subcat.list <#1 . #sc>],
                  args <[synsem.loc.cat.subcat.list #sc]>].



eps-vcomp-0 := restr-eps-vc-rule & 
                 [synsem.loc.cat [head.v1.cat [subj #subj & *eps-1-list*,
                                              subcat.list <>],
                                  subcat.list #sc &  *eps-3-list*],
                  args <[synsem prd-adj-or-non-fin-verb-synsem & 
				[loc.cat [head.subj #subj,
					  subcat.list #sc ]]]>].



eps-vcomp-3-nosubj := eps-vc-rule-s0-1+ & 
		      [synsem.loc.cat [head [v1.cat [subcat.list <#3>]],
				       subcat.list <#1,#2,#3   . #sc>],
		       args <[synsem.loc.cat.subcat.list <#1,#2 . #sc>]>].

eps-vcomp-2-nosubj := eps-vc-rule-s0-1+ & 
		      [synsem.loc.cat [head [v1.cat [subcat.list <#2>]],
				       subcat.list <#1,#2  . #sc>],
		       args <[synsem.loc.cat.subcat.list <#1 . #sc>]>].

eps-vcomp-1-nosubj := eps-vc-rule-s0-1+ & 
		      [synsem.loc.cat [head [v1.cat [subcat.list <#1>]],
				       subcat.list <#1 . #sc>],
		       args <[synsem.loc.cat.subcat.list #sc]>].

eps-part_-vc := eps-vc-rule-part & [synsem.loc.cat [vcomp <>],
			   args <[synsem.loc.cat.head._vc sp-form_-]>].

eps-part_+vc-0 := eps-vc-rule-part & 
		  [synsem.loc.cat [vcomp <prd-adj-or-non-fin-verb-synsem >
					 ],
		   args <[synsem.loc.cat.head._vc sp-form_+]>].

imperative := imp-rule-type.

imperative-3pl := imp-bin-rule-type.


yes-no-question := yes-no-q-rule.

aux-s := cf-s-rule-type &
	 [head-dtr [synsem.loc [cont [hook [index #e,
					    ltop #l],
				      rels <! !>],
				cat [head initial_+_fin-verb-head &
					  [aux +],
				     subcat.list <[loc [cont.hook [index #e,
								   ltop #l],
							cat.head eps-verb-head ]]>]]],
	  non-head-dtr [synsem.loc [cont.hook [index #e,
					       ltop #l],
				    cat.head._v1.cat.vcomp <[loc.cont.hook [index #e,
									    ltop #l]], ...>]]].

v1-s := cf-s-rule-type &
	[head-dtr [synsem.loc [cont [hook.index #e,
				     rels.list <[], ... >],
			       cat [head initial_+_fin-verb-head & [aux -],
				    subcat.list <[loc [cont.hook.index #e,
						       cat.head eps-verb-head ]]>]]]].


comp-s := cf-s-rule-type &
	      [head-dtr [synsem.loc.cat.head complementizer-head ]].




reorder-2-1 := 
                     reorder-lrule &
                     [synsem.loc.cat.subcat.list <#2 & [loc.cat.opt -] ,#1 .#sc> ,
                      args.first.synsem.loc.cat.subcat.list <#1,#2 . #sc> ].


reorder-3-1 := 
                   reorder-lrule &
                   [synsem.loc.cat.subcat.list <#3 & [loc.cat.opt -],#2,#1 .#sc> ,
                    args.first.synsem.loc.cat.subcat.list <#1,#2,#3 . #sc>].
reorder-3-2 :=
                  reorder-lrule &
                  [synsem.loc.cat.subcat.list <#1,#3 & [loc.cat.opt -],#2 . #sc>,
                   args.first.synsem.loc.cat.subcat.list <#1,#2,#3 .#sc>].