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

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

;;; Copyright: DFKI GmbH


headed-phrasal-sign :=
  grammar-rule & [
  head-dtr sign
  ].

non-head-dtr-sign :=
		    grammar-rule & 
		    [non-head-dtr sign].

head-non-head-sign :=
  headed-phrasal-sign &
  non-head-dtr-sign.


hfp :=
      headed-phrasal-sign &
      [synsem.loc [ cat.head #h,
		    uniagr #uniagr
			     ],
       head-dtr.synsem.loc [ cat.head #h,         
			     uniagr #uniagr 
				      ]
		  ].


headed-rule :=
	      hfp & [synsem.loc [cat.head.--zu -,
				 coord na_or_-,
				 cont.hook [--oind #oind,
					    --reli #i,
					    --relh #h]],
		     head-dtr.synsem.loc.cont.hook [--oind #oind,
						    --reli #i,
						    --relh #h]  
				      ].



basic-binary-punct-rule :=
                   grammar-or-mw-rule &  
                   [ SYNSEM [LOC.CONT.HOOK.INDEX.--PUNCT #--p,
			     PUNCT.--left_sister_rpunct #lrpunct],
		     SIGNPUNCT [ LPUNCT #lpunct,
                                 RPUNCT #rpunct ],
                     ARGS < sign & [ SYNSEM [LOC.CONT.HOOK.INDEX.--PUNCT #--p,
					     PUNCT.--left_sister_rpunct #lrpunct],
				     SIGNPUNCT [ PAIRED.PPAIRACCURACY #punctacc,
                                                 LPUNCT #lpunct,
                                                 RPUNCT comma_or_semicol_or_paren_or_dash_or_no_punct_min & 
								      [ PUNCTACCURACY #punctacc ],
						 PAREN advers_comma_punct_min ],
				     RESTR-COLL.SPANNING-ONLY -
                                            ],
                            sign & [ SYNSEM.LOC.CONT.HOOK.INDEX.--PUNCT #--p,
				     SIGNPUNCT.RPUNCT #rpunct,
				     RESTR-COLL.SPANNING-ONLY - ]
                           > ].

cle-binary-rule := 
                   grammar-rule & 
                   basic-binary-punct-rule &
                   [MAL #mal,
		    MALRULE #malrule,
                    lr lr-syntax_min,
                    ARGS < sign & [ synsem.lex-complete +,
				    MAL #mal,
				    MALRULE #malrule,
                                    lr lr-syntax_min
                                                        ],
                           sign & [ MAL #mal,
				    MALRULE #malrule,
				    synsem.lex-complete +,
                                    lr lr-syntax_min ]
                           >
                       ].

cle-ternary-rule := ternary-sign &
		    [ lr lr-syntax_min,
		      ARGS < sign & [ synsem.lex-complete +,
				      lr lr-syntax_min ],
			     sign & [ synsem.lex-complete +,
				      lr lr-syntax_min ],
			     sign & [ synsem.lex-complete +,
				      lr lr-syntax_min ]
                           > ].

basic_cle-unary-rule :=
  grammar-rule &
  unary-rule_min &
  [ MAL #mal,
    MALRULE #malrule,
    MORPH no_morph,
    synsem [lper #l,
	  rper #r,
	  loc.coord -,
	  PUNCT [ --LEFT_SISTER_RPUNCT #lsr,
		  --INF_PPAIR #infppair ]],
  SIGNPUNCT [ LPUNCT #lpunct,
              RPUNCT #rpunct,
	      PUNCTPAIR #punctpair,
	      INFPUNCT [ --LEFT_INFCOMMA #linfc,
			 --RIGHT_INFCOMMA #rinfc ],
	      PAREN #paren ],
  lr lr-syntax_min,         
  ARGS < sign & [ MAL #mal,
		  MALRULE #malrule,
         SYNSEM [LPER #l,
		 RPER #r,
		 LEX-COMPLETE +,
	  PUNCT [ --LEFT_SISTER_RPUNCT #lsr,
		  --INF_PPAIR #infppair ]],
	 SIGNPUNCT [ LPUNCT #lpunct,
                     RPUNCT #rpunct,
		     PUNCTPAIR #punctpair,
		     INFPUNCT [ --LEFT_INFCOMMA #linfc,
				--RIGHT_INFCOMMA #rinfc ],
		     PAREN #paren],	 
         lr lr-syntax_min
         ]
       >
	].

inher-punctpaired-unary-rule :=
  unary-rule_min &
  [ SIGNPUNCT.PAIRED #paired,
    ARGS < [ SIGNPUNCT.PAIRED #paired ] > ].

cle-unary-rule :=
  basic_cle-unary-rule &
  inher-punctpaired-unary-rule &
  inher-left-sister-paired-rule.


headed-binary-rule :=
		     headed-rule     &
		     head-non-head-sign &
		     cle-binary-rule &
		     [ARGS <[SYNSEM.LEX-COMPLETE +],
			    [SYNSEM.LEX-COMPLETE +]>].

headed-unary-rule :=
		    headed-rule    &
		    cle-unary-rule &
		    [ARGS <[SYNSEM.LEX-COMPLETE +]>].

unheaded-binary-rule :=
  unheaded-rule   &
  cle-binary-rule &
  apply-left-sister-rpunct-rule-type &
  [ ARGS < [ ], [ ] > ].

unheaded-unary-rule :=
  unheaded-rule  &
  basic_cle-unary-rule.

inher-rel :=
  grammar-rule &
  [
  synsem.nonloc.rel        *diff-list* &
			   [ LIST #first,
			     LAST #last ],
  ARGS < [
         synsem.nonloc.rel *diff-list* &
			   [ LIST #first,
			     LAST #middle ]
         ],
         [
         synsem.nonloc.rel *diff-list* &
			   [ LIST #middle,
			     LAST #last ]
         ]
        >
   ].            

inher-que :=
  grammar-rule &
  [
  synsem.que        *diff-list* &
			   [ LIST #first,
			     LAST #last ],
  ARGS < [
         synsem.que *diff-list* &
			   [ LIST #first,
			     LAST #middle ]
         ],
         [
         synsem.que *diff-list* &
			   [ LIST #middle,
			     LAST #last ]
         ]
        >
   ].            


inher-slash :=
  head-non-head-sign &
  [
  synsem.nonloc [--tpc #tpc,
		 --top #top,
		 _topic-drop #td,
		 _slash        *diff-list* &
			     [ LIST #_first,
			       LAST #_last ],

		 slash        *diff-list* &
			     [ LIST #first,
			       LAST #last ]],
   head-dtr [
	 synsem.nonloc [--top #top,
			--tpc #tpc,
			_topic-drop #td,
			_slash *diff-list* &
				    [ LIST #_first,
				      LAST #_middle ],
			slash *diff-list* &
				    [ LIST #first,
				      LAST #middle ]]
	 ],
  non-head-dtr [
	 synsem.nonloc [_slash *diff-list* &
			      [ LIST #_middle,
				LAST #_last ],
			slash *diff-list* &
			      [ LIST #middle,
				LAST #last ]
	 ]]
  ].            


inher-nonloc2 := 
  inher-rel &
  inher-que &
  inher-slash & [ARGS <[vf -],[vf -]>].

#|
 inher-nonloc := 
                *rule* & 
               [synsem [ nonloc [_topic-drop #td,
                                 _slash #_slash,
                                 slash #slash,
                                 rel #rel],
                          que    #que
                                 ],
                 ARGS < [ vf -,
                         synsem [ nonloc [_topic-drop #td,
                                          slash #slash,
                                          _slash #_slash,
                                          rel #rel],
                                   que    #que
                                          ] 
                                 ]>].
|#

inher-nonloc := 
                *rule* & 
               [synsem [ nonloc #nloc,
                          que    #que
                                 ],
                 ARGS < [ vf -,
                         synsem [ nonloc #nloc & nonlocal,
                                   que    #que
                                          ] 
                                 ]>].

inher-nonloc-unheaded-unary-rule :=
  inher-nonloc &
  unheaded-unary-rule.


head-mrs-princ := headed-phrasal-sign &
  [ SYNSEM.LOC.CONT [ HOOK [LTOP #h,
			    INDEX #i],
                      KEY #key,
                      MODCONT #modcont ],
    HEAD-DTR.SYNSEM.LOC.CONT [ HOOK [LTOP #h,
				     INDEX #i],
                               KEY #key,
                               MODCONT #modcont ] ].

unary-headed-mrs-lrule :=
			 *unary-headed-mrs-lrule* & lrule.

*unary-headed-mrs-lrule* :=
			 *lrule* &
			 [ SYNSEM.LOC.CONT [ hook [ltop #h,
						   INDEX #i],
					     KEY #key,
					     MODCONT #modcont ],
			   ARGS <[SYNSEM.LOC.CONT [ hook [ltop #h,
							  INDEX #i],
						      KEY #key,
						      MODCONT #modcont ] ]>].


head-comp-sem-princ := head-mrs-princ &
		       non-head-dtr-sign & 
		       [synsem.loc.cont.hook [xarg #x],
			head-dtr [synsem.loc.cont.hook [xarg #x]]].


head-vcomp-sem-princ := head-mrs-princ & 
			non-head-dtr-sign.


v-mod-sem-princ := headed-phrasal-sign & 
		   non-head-dtr-sign &
		   [ SYNSEM.LOC.CONT [ hook [index #x,
					     ltop #h],
				       KEY #key],
		     HEAD-DTR.SYNSEM.LOC.CONT [ hook [index #x,
						      ltop #h],
						KEY #key ] ].

;;; 10/12/2011: The next 3 principles have not been changed yet. 
head-mod-sem-princ := 
		      headed-phrasal-sign & 
		      non-head-dtr-sign &
		      [ SYNSEM.LOC.CONT [ hook [index #x,
						ltop #h],
					  KEY #key ],
			NON-HEAD-DTR [synsem.loc [cont [hook.ltop #h]]],
			HEAD-DTR.SYNSEM.LOC.CONT [ hook [index #x],
						   KEY #key ] ].

;; BC: New principle for sound scopal modifiers 
#|
configurational-scopal-mod-sem-princ := 
			     collect-constr-2-liszt &
			     headed-phrasal-sign & 
			     non-head-dtr-sign &
			     [C-CONT [RELS <! !>,
				      HCONS <! 
					     [HARG #s,
					      LARG #b] !>],
			      SYNSEM.LOC.CONT [hook [ltop #t,
						     lbot #b,
						     INDEX #i],
					       key #k,
 					       modcont [hook [ltop #s,
							      index #i]]],
			      NON-HEAD-DTR.SYNSEM.LOC.CONT scopal-mod-sem-type & 
				     [ hook [ltop #t],
				       MODCONT [hook [ltop #s]]] ,
			      HEAD-DTR.SYNSEM.LOC.CONT [hook [index #i,
							      LTOP #b],
							key #k] ].

nonconfigurational-scopal-mod-sem-princ := 
			     collect-constr-2-liszt &
			     headed-phrasal-sign & 
			     non-head-dtr-sign &
			     [C-CONT [RELS <! !>,
				      HCONS <! 
					     [HARG #t,
					      LARG #h], 
					     [HARG #s,
					      LARG #b] !>],
			      SYNSEM.LOC.CONT [hook [ltop #t,
						     INDEX #i],
					       key #k,
					       modcont [hook [ltop #s,
							      index #i]]],
			      NON-HEAD-DTR.SYNSEM.LOC.CONT scopal-mod-sem-type & 
					      [ hook [ltop #h],
						MODCONT [hook [ltop #s]]] ,
			      HEAD-DTR.SYNSEM.LOC.CONT [hook [index #i,
							      LTOP #t,
							      lbot #b],
							key #k] ].
|#


head-sem-princ := headed-phrasal-sign &
  [ SYNSEM.LOC.CONT #cont,
    HEAD-DTR.SYNSEM.LOC.CONT #cont ].

constr-unary-type := constr-type & 
		     root-or-non-root-sign &
		     args-type &
		        [ SYNSEM.LOC.CONT [RELS [ LIST #list1,
						  LAST #last2 ],
					   HCONS [ LIST #hcons1,
						   LAST #hlast2 ]
						],
			  C-CONT [ RELS [ LIST #list1,
					  LAST #list2 ],
				   HCONS [ LIST #hcons1,
					   LAST #hcons2 ] ],
			  ARGS < [ SYNSEM.LOC.CONT [ RELS [ LIST #list2,
							      LAST #last2 ],
						       HCONS [ LIST #hcons2,
							       LAST #hlast2 ] ] ]> ].


constr-unary-sem-princ :=
			 head-mrs-princ & constr-unary-type.


*constr-unary-lrule* := *unary-headed-mrs-lrule* & constr-unary-type.


constr-unary-lrule := *constr-unary-lrule* &
		     unary-headed-mrs-lrule.

head-constr-unary-sem-princ := 
			       constr-unary-sem-princ.
                       

head-liszt-2-rule := head-comp-sem-princ &
                     collect-2-liszt.

head-constr-2-rule := head-comp-sem-princ &
                      collect-constr-2-liszt.

vc-mrs-binary-rule := head-vcomp-sem-princ & collect-2-liszt.


head-mod-liszt-2-rule := head-mod-sem-princ &
			 collect-2-liszt.

head-mod-constr-2-rule := head-mod-sem-princ &
                          collect-constr-2-liszt.

head-mrs-binary-rule := head-liszt-2-rule.

head-mrs-constr-binary-rule :=
			      head-constr-2-rule.

head-mrs-spec-binary-rule := 
			     collect-constr-2-liszt   &   
			     headed-phrasal-sign      &
			     [ SYNSEM.LOC.CONT [hook [INDEX #ind],
						KEY #key ],
			       HEAD-DTR.SYNSEM.LOC.CONT [ KEY #key ],
			       ARGS < [  ], 
				      [ SYNSEM.LOC.CONT.HOOK [INDEX #ind ] ] > ].

empty-det-sem-rule := phrasal-sign & 
		      constr-type &
		      [ c-cont [rels <! #det & [lbl #t] !> ],
			SYNSEM [ LOC.CONT bare-np-sem-type &
					  [ hook [xarg #xarg,
						  INDEX #ind,
						  LTOP #t],
					    KEY #key,
					    RELS [ LIST < #det &
							  [ RSTR #restr ] . #liszt >,
						   LAST #lilast ],
					    HCONS [ LIST < qeq & [HARG #restr,
								  LARG #h] . #hlist >,
						    LAST #hlast ] ] ],
			ARGS < [ SYNSEM.LOC [ CAT.SPR < [ LOC.CONT.KEY #det ]  >,
					      CONT [ hook [xarg #xarg, 
							   INDEX #ind,
							   ltop #h],
						     KEY #key,
						     RELS [ LIST #liszt,
							    LAST #lilast ],
						     HCONS [ LIST #hlist,
							     LAST #hlast ] ] ] ]  > ].



adj-noun-sem-rule := phrasal-sign &
		     constr-type &
		     [ C-CONT [RELS <! #key !>,
			       HCONS <! !>],
		       SYNSEM [ LOC.CONT [ hook [INDEX #ind,
						 ltop #hand],
					   KEY #key &
						abstr_nom_rel &
						[ pred "abstr_nom_rel",
						  ARG0 #ind,
						  LBL #hand ],
					   RELS [ LIST < #key . #adjsem >,
						  LAST #adjlast ],
					   HCONS #adj-hcons ] ],
		       ARGS < [ SYNSEM.LOC [CAT.HEAD.MOD.LOC.CONT.HOOK.INDEX #ind,
					    CONT [HOOK [ XARG #ind,
							 ltop #hand ],
						  RELS [ LIST #adjsem,
							 LAST #adjlast ],
						  HCONS #adj-hcons ] ]] > ].





det-noun-sem-rule := phrasal-sign &
   [ SYNSEM [ LOC.CONT [ hook [INDEX #ind,
			       ltop #hand],
                         KEY #key &
                              abstr_nom_rel &
                               [ PRED "abstr_nom_rel",
				 ARG0 #ind,
                                 LBL #hand ],
                         RELS [ LIST < #key . #detsem >,
                                 LAST #detlast ],
                         HCONS #det-hcons ] ],
     ARGS < [ SYNSEM.LOC.CONT [ MODCONT.HOOK [ INDEX #ind,
					       ltop #hand ],
                                RELS [ LIST #detsem,
                                        LAST #detlast ],
                                HCONS #det-hcons ] ] > ].



price-pp-noun-sem-rule := phrasal-sign &
			  [ SYNSEM [ LOC.CONT [hook [INDEX #ind & 
							   [SORT abstract,
							    png p-s-g
								 ],
						     ltop #hand],
					       KEY #key &
						    std_nom_rel &
						    [ PRED   "preis",
						      ARG0   #ind,
						      LBL #hand ],
					       RELS [ LIST < udef_rel &
							     [ ARG0 #ind,
							       LBL #hand
								    ],
							     #key . #adjsem >,
						      LAST #adjlast ],
					       HCONS [ LIST <  #adj-hcons-list >,
						       LAST #adj-hcons-last
							    ]
						    ] ],
			    ARGS < [ SYNSEM.LOC.CONT [ MODCONT.HOOK [ INDEX #ind,
								      ltop #hand ],
						       key ueber-um-unter-prep-mod-rel,
						       RELS [ LIST #adjsem & [REST.REST.FIRST currency_rel
											      ],
							      LAST #adjlast ],
						       HCONS [ LIST #adj-hcons-list,
							       LAST #adj-hcons-last 
								    ] ] ] > ].



eps-sem-transport-rule := phrasal-sign &
			  [ SYNSEM.LOC [ CAT.HEAD.V1.CONT [ key #key,
							    hook [ltop #h,
								  INDEX #i] ],
					 CONT [ key #key,
						hook [ltop #h,
						      INDEX #i & event],
						MODCONT #modcont,
						RELS #arglist,
						HCONS #argcons ] ],
			    ARGS < [ SYNSEM.LOC.CONT [ RELS #arglist,
						       HCONS #argcons,
						       MODCONT #modcont ] ] > ].

eps-v-sem-transport-rule :=
			   eps-sem-transport-rule.

eps-adj-sem-transport-rule := eps-v-sem-transport-rule.

eps-vc-sem-transport-rule :=
			    eps-sem-transport-rule.

collect-coord-constr-2-liszt := 
				grammar-rule & 
				constr-type &
				[ SYNSEM.LOC.CONT [ KEY #key,
						    RELS [ list < #key . #liszt1 >,
							   last #llast2 ],
						    HCONS [ list #sc,
							    last #sclast2] ],
				  C-CONT [ RELS [ list #liszt,
                      last #llast2 ],
              HCONS [ list #sc,
                       last #sclist1 ] ],
     ARGS < [synsem.loc.CONT [ RELS [ list #liszt1, 
                                    last #liszt2 ],
                               HCONS [ list #sclist1,
                                        last #sclist2 ] ] ],
            [ synsem.loc.CONT [ RELS [ list < [] . #liszt2 >,
                                        last #liszt ],
                                HCONS [ list #sclist2,
                                         last #sclast2 ] ]
                              ] > ].



coord-mrs-binary-rule :=
			grammar-rule &
			constr-type & 
			[synsem.loc.cont [modcont #mc & [hook [index #mcind]],
					  rels [list #rlist1,
						last #rlist4],
					  hcons [list #hlist1,
						 last #hlist4]],
			 c-cont [rels [list #rlist3,
				       last #rlist4],
				 hcons [list #hlist3,
					last #hlist4]],
			 args <[synsem.loc.cont [modcont [hook [index  #mcind]],
						 rels [list #rlist1,
						       last #rlist2],
						 hcons [list #hlist1,
							last #hlist2]
						      ]],
			       [synsem.loc.cont [modcont #mc,
						 rels [list #rlist2,
						       last #rlist3],
						 hcons [list #hlist2,
							last #hlist3]
						      ]]>].


topic-mrs-marking-princ := non-head-dtr-sign &
                           constr-type &
                           [ C-CONT [ RELS <!  !>,
                                      HCONS <! !> ]].



head-first-rule :=
		  headed-binary-rule & 
		  [synsem [lper #l,
			   rper +],
		   head-dtr #hd & [synsem [lper #l] ],
		   non-head-dtr #nhd,
		   ARGS <
			 #hd,
			 #nhd
			 >
			    ].

head-last-rule :=
		 headed-binary-rule          & 
		 [synsem [lper +,
			  rper #r],
		   head-dtr #hd & [synsem [rper #r] ],
		  non-head-dtr #nhd & [synsem.loc.sgf sgf-lee- ],
		  ARGS <#nhd,
			#hd
			>].


head-last-spec-p-2 := 
		      head-last-rule &
		      [ ARGS <[ synsem.loc.cat.head.spec [ loc [ cat.head #head,
								 cont     #cont
									  ],
							   nonloc #nonloc
							       ]
							 ],
			      [ synsem [ loc [ cat.head #head,
					       cont     #cont
							],
					 nonloc #nonloc
					     ]
				       ]
			      >
			     ].