;;; -*- 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






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,
		    cont.message #msg
			     ],
       head-dtr.synsem.loc [ cat.head #h,         
			     uniagr #uniagr,
			     cont.message #msg
				      ]
		  ].


headed-rule :=
  hfp & [
  synsem.loc.coord na_or_-
  ].



cle-binary-rule := 
                   grammar-rule &
                   [lr lr-syntax,
                    ARGS < sign & [ synsem.lex-complete +,
                                    lr lr-syntax
                                                        ],
                           sign & [ synsem.lex-complete +,
                                    lr lr-syntax ]
                           >
                       ].


cle-unary-rule :=
  grammar-rule &
  [ MORPH <! !>,
  synsem.loc.coord -,
  lr lr-syntax,         
  ARGS < sign & [
         synsem.lex-complete +,
         lr lr-syntax
         ]
       >
  ].





headed-binary-rule :=
  headed-rule     &
  head-non-head-sign &
  cle-binary-rule.

headed-unary-rule :=
  headed-rule    &
  cle-unary-rule.

unheaded-binary-rule :=
  unheaded-rule   &
  cle-binary-rule.

unheaded-unary-rule :=
  unheaded-rule  &
  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 [_topic-drop #td,
		 _slash        *diff-list* &
			     [ LIST #_first,
			       LAST #_last ],

		 slash        *diff-list* &
			     [ LIST #first,
			       LAST #last ]],
   head-dtr [
	 synsem.nonloc [_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.

inher-nonloc := 
		*rule* & 
		[synsem [ nonloc [_topic-drop #td,
				  _slash #_slash,
				  slash #slash,
				  rel #rel],
			  que    #que
				 ],
		 ARGS < [ synsem [ nonloc [_topic-drop #td,
					   slash #slash,
					   _slash #_slash,
					   rel #rel],
				   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],
                      MESSAGE #m,
                      KEY #key,
                      MODCONT #modcont ],
    HEAD-DTR.SYNSEM.LOC.CONT [ hook [ltop #h,
				     INDEX #i],
                               MESSAGE #m,
                               KEY #key,
                               MODCONT #modcont ] ].

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


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


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



head-mod-sem-princ := 
		      head-mrs-princ & 
		      non-head-dtr-sign &
		      [NON-HEAD-DTR.SYNSEM.LOC.CONT [ MODCONT #modcont ],
		       HEAD-DTR.SYNSEM.LOC.CONT #modcont ].

;; BC: New principle for sound scopal modifiers
head-scopal-mod-sem-princ := 
			     headed-phrasal-sign & 
			     non-head-dtr-sign &
			     [SYNSEM.LOC.CONT [hook [ltop #h,
						     INDEX #i],
					       key #k,
					       message #m,
					       modcont [hook [ltop #scop,
							      index #i]]],
			      NON-HEAD-DTR.SYNSEM.LOC.CONT scopal-mod-sem-type & 
					      [ hook [ltop #h],
						MODCONT [hook [ltop #scop]]] ,
			      HEAD-DTR.SYNSEM.LOC.CONT [hook [index #i,
							      ltop #scop],
							key #k,
							message #m] ].

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

constr-unary-sem-princ :=
   head-mrs-princ & constr-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 ] ],
     HEAD-DTR [ SYNSEM.LOC.CONT [ RELS [ LIST #list2,
					 LAST #last2 ],
				  HCONS [ LIST #hcons2,
					  LAST #hlast2 ] ] ] ].


constr-unary-lrule :=
		     unary-headed-mrs-lrule & constr-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 ] ] ]> ].

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-liszt-2-rule.


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,
		      MESSAGE #mess ],
     HEAD-DTR.SYNSEM.LOC.CONT [ KEY #key,
				MESSAGE #mess ],
     ARGS < [ SYNSEM.LOC.CONT [
			       MESSAGE #mess ] ], 
	    [ SYNSEM.LOC.CONT.HOOK.INDEX #ind ] > ].

empty-det-sem-rule := phrasal-sign & 
		      constr-type &
		      [ c-cont [rels <! #det !> ],
			SYNSEM [ LOC.CONT bare-np-sem-type &
					  [ hook [INDEX #ind],
					    KEY #key,
					    MODCONT #modcont,
					    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 & [PRED "udef_q_rel"] ] >,
					      CONT [ hook [INDEX #ind,
							   ltop #h],
						     KEY #key,
						     MODCONT #modcont,
						     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.CONT [ MODCONT.HOOK [ INDEX #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 &
                               [ 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 [ hook [ltop #h,
								  INDEX #i],
							    KEY #key,
							    MESSAGE #m ],
					 CONT [ hook [ltop #h,
						      INDEX #i & event],
						MESSAGE #m,
						MODCONT #modcont,
						RELS #arglist,
						HCONS #argcons ] ],
			    ARGS < [ SYNSEM.LOC.CONT [ KEY #key,
						       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]],
					  message [pred #msg],
					  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]],
						 message [pred #msg],
						 rels [list #rlist1,
						       last #rlist2],
						 hcons [list #hlist1,
							last #hlist2]
						      ]],
			       [synsem.loc.cont [modcont #mc,
						 message [pred #msg],
						 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          & [
 head-dtr #hd,
 non-head-dtr #nhd,
  ARGS <
         #hd,
         #nhd
       >
  ].

head-last-rule :=
		 headed-binary-rule          & 
		 [head-dtr #hd,
		  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
                    ]
           ]
           >
         ].