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


inher-anc-lrule :=
		  lrule & 
		  [synsem.loc.anc #anc ,
		   ARGS <[synsem.loc.anc #anc]>
				  ].



infl_lrule-sign :=
		  infl_lrule   & 
		  lexical-sign & 
		  [ARGS < lexical-sign >].

infl_lrule-arche-form :=
  infl_lrule & 
  stem       & [
  ARGS < arche-form >
  ].


noninfl-lrule :=
  inher-anc-lrule & [ 
  ARGS < stem-or-stempunct & [lr.lr_inflected +]>
  ].

final-lrule :=
	      lexical-sign  &
	      noninfl-lrule & 
	      [lr lr-syntax_min
		  ].

post-infl-lrule :=
		  punct-lrule-noarg-lrule &
		  [lr.lr_inflected #i,
		   args <[lr.lr_inflected #i & +]>].

nonfinal-noninfl-lrule :=
  stem &
  noninfl-lrule.

basic-clex-lrule-type := 
  final-lrule & 
  lexical-nonloc-default.

clex-lrule-type :=
  basic-clex-lrule-type &
  [ ARGS < stem > ].

clex-lrule :=
  basic-clex-lrule-type &
  punct-lrule-noarg-lrule.

clex-id-lrule :=
  clex-lrule & [
  morph  #m,
  synsem #synsem,
  ARGS < stem &  [ morph #m,
             synsem #synsem 
           ]
        >
   ].

inher-nonloc-lrule :=
  inher-nonloc &
  noninfl-lrule.


mark-no-rel := stem-or-sign & [
   synsem.loc.cat.subcat.list *eps-no-rel-synsem-list*
   ].

mark-undef-nonlocs := lrule & 
		      *mark-undef-nonlocs*.

*mark-undef-nonlocs* := *lrule* & [
   synsem.loc.cat [ head.subj < [ nonloc undef-nonlocs ] >,
                    subcat.list  *eps-undef-nonlocs-synsem-list*
                  ]
   ].

     
no-rel-inher-nonloc-lrule :=
			    mark-no-rel &
			    inher-nonloc-lrule &
			    punct-lrule-noarg-lrule &
			    [synsem.que #que,
			     args <[synsem.que #que]>].

nonfinal-no-rel-inher-nonloc-lrule :=
  nonfinal-noninfl-lrule &
  no-rel-inher-nonloc-lrule.

final-inher-nonloc-lrule :=
  final-lrule &
  inher-nonloc-lrule.

final-no-rel-inher-nonloc-lrule :=
  final-inher-nonloc-lrule &
  no-rel-inher-nonloc-lrule.


fin-flex-final-lrule :=
		       fin-verb-flex &
		       post-infl-lrule & 
		       final-lrule.


fin-lrule :=
	    post-infl-lrule &
	    --tpc-nonloc-reent &
	    final-lrule & [morph  #m,
			   synsem fin-verb-synsem & #synsem & [
	  loc [ _third -,
		cat.head v-final-head,
		cont.hook.index.e  tensed,
		anc [self <! !>,
		     active <! !>,
		     inert <! !>],
                sgf sgf-lor-
              ]
          ],

   ARGS <   [
            morph  #m,
            synsem #synsem,
            lr.basic  na
            ]
        > 
   ].

v1-fin-lrule-rb :=
		  post-infl-lrule &
		  final-inher-nonloc-lrule &  
		  [morph  #m,
		   synsem fin-verb-synsem & 
			  [loc [_third -,
				sgf #sgf,
				cat [head   #h & initial_+_fin-verb-head,
				     subj <>,
				     ucomps #uc & <>,
				     subcat <! saturated-comp-fin-verb-synsem & 
					     [loc [cat [head eps-verb-head & 
							     [_v1-hd #v1-hd,
							      v1 fin-verb-local & 
								  [cat [head   #h,
									subj #subj,
									subcat #subcat,
									vcomp  #vcomp 
									       ],
								   cont  [ key #key,
                                                                           hook [ index #index & [--sub -],
										       ltop #handle]]
								       ]
								  ]
							     ],
						   sgf #sgf
						       ]
						  ]
					       !> & [LAST *null*],
				       vcomp  <>],
				 adjunction  unmodifiable,
				cont #cont & [ key #key,
                                               hook [index #index & [--sub -],
						    ltop #handle]],
				 anc anc-inactive
				     ],
			   v2 #v2
	  ],
		   lr.basic  -,
		   ARGS <   [morph  #m & <! [head.fin.--tpc tpc-nonevent] !>,
			     synsem fin-verb-synsem & [ 
		   loc [ cat [ head   #h,
			       subj #subj,
			       subcat #subcat,
			       ucomps #uc,
			       vcomp  #vcomp & <[loc [cat.head #v1-hd]] , ...>
			       ],
			 cont #cont],
							v2 #v2
		   ],
            lr [basic  na]
				    ]
			    > 
   ].

v1-fin-lrule-no-rb :=
		     post-infl-lrule &
		     --tpc-nonloc-reent & 
		     final-inher-nonloc-lrule &  
		     [morph  #m,
		      synsem fin-verb-synsem & 
			     [loc [ _third #3rd,
				    cat [ head   #h & initial_+_fin-verb-head & [extra na_or_+],
                      subj #subj,
		      ucomps #uc,
                      subcat #subcat & [LAST *null*],
                      vcomp #vcomp
                      ],
		cont #cont & [hook.index [--sub -]],
		sgf sgf-lor-
                    ],
            v2 #v2
          ],
   lr.basic  -,
   ARGS <   [
            morph  #m,
            synsem fin-verb-synsem & [ 
                   loc [_third #3rd,
			cat [ head   #h,
			      subj #subj,
			      ucomps #uc,
			      subcat #subcat,
			      vcomp #vcomp & *list* & *null*
				     ],
			 cont #cont
                         ],
                     v2 #v2
                  ],
            lr [basic  na]
            ]
        > 
   ].





particle-lrule :=
		 stem &
		 spell-lrule &
		 basic-punct-lrule &
		 inher-nonloc &
		 constr-type &
		 [needs-affix +,
		  morph  <! [head #m] !>,
		  c-cont [rels <! #partrel !>,
			  hcons <! !>],
		  synsem verb-synsem & 
			 [loc [ anc #anc ,
				cat [ head  #h & initial_-_-head,
				      vcomp #vcomp & *vc-eps-list*,
				      subj #subj,
				      ucomps #uc,
				      subcat #sc,
				      auxf #auxf
					    ],
				cont [key #k,
				      hook [index #index,
					    ltop #lbl,
					    lbot #b ],
				      modcont.hook #modcont,
				      hcons #hcons,
				      rels [list <#partrel . #rels>,
					    last #rlast]],
				adjunction #adj,
				erg #erg
				    ],
			  v2 #v2,
			  nonloc contains-no-rel
			      ],


		  lr [lr_inflected #i & +,
		      p -,
		      basic  #basic,
		      reorder #r,
		      PUNCT-LR-ARG prefix-lr-arg ],
		  ARGS <   [ morph  <! [head #m & [mclass vclass]] !>,
			     synsem particle-or-more-verb-synsem &
				    [loc [ anc #anc,
					   cat [ head  #h & [vform real-vform-sm],
						 vcomp <particle-sep-or-nonsep-synsem & 
							[loc.cont [key #partrel & [arg0 event & [e no_tam]]]] . #vcomp>,
						 subj #subj,
						 subcat #sc,
						 ucomps #uc,
						 auxf #auxf
						       ],
					   cont [key #k,
						 hook [index #index,
						       ltop #lbl,
						       lbot #b ],
						 modcont.hook #modcont,
						 hcons #hcons,
						 rels [list #rels,
						       last #rlast]],
					   adjunction #adj,
					   erg #erg
					       ],
				     v2 #v2
					 ],
			     lr [lr_inflected #i,
				 p  bool,
				 basic  #basic & +,
				 reorder #r & 'yes]
				    ]
			   > 
			 ].


general-SILR-lrule :=
		     post-infl-lrule &
		     nonfinal-no-rel-inher-nonloc-lrule & 
		     [morph  #m,
		      synsem fin-verb-synsem & 
			     [loc [_third #3rd,
				   cat [ head  #h & [subj <>],
					 vcomp #vcomp,
					 subj #subj,
					 subcat #sc,
					 ucomps #uc
					       ],
				   cont #cont,
				   adjunction #adj
					  ],
			      v2 #v2
				  ],
		      cle -,
		      lr [basic  na],
		      ARGS <   [ morph  #m & <! morph-type !>,
				 synsem verb-synsem & 
					[loc [_third #3rd,
					      cat [ head  #h,
						    ucomps #uc,
						    vcomp #vcomp,
						    subj #subj,
						    subcat #sc
							  ],
					      cont #cont ,
					      adjunction #adj
						     ],
					 v2 #v2
					     ],
				 lr.basic  +
					]
			       > 
			     ].


SILR-lrule :=
	     general-SILR-lrule &
	     fin-verb-flex.

general-pers-SILR-lrule-type :=
			       general-SILR-lrule &
			       [ARGS < [morph  <! [ head [fin [uniagr #agr & [png #png]]]
							 ] !>,
					synsem.loc [cat.subj < noun-synsem & 
							       [loc [ cat.head.cas struc-nom,
								      cont.hook [INDEX [png #png
											    ]],
								      uniagr #agr & n-n-g & [cas struc-nom]
										   ]
								    ] >
							     ]
					       ]
				       > 
				     ].


MAL-pers-SILR-lrule-type := SILR-lrule &
			    [ARGS < [synsem.loc [cat.subj < noun-synsem & 
							    [loc [ cat.head.cas struc-nom,
								   uniagr n-n-g & [cas struc-nom]
										   ]
								 ] >
							  ]
					       ]
				    > 
				  ].


pers-SILR-lrule-type := general-pers-SILR-lrule-type &
			SILR-lrule.

general-unpers-SILR-lrule-type :=
   general-SILR-lrule & [
   ARGS <   [
            morph  <! [ head.fin.uniagr.png 3-s-g
                      ] !>,
            synsem.loc.cat [ subj *empty-or-clausal-complement-synsem-list*
				  ]
            ]
        > 
   ].

unpers-SILR-lrule-type := general-unpers-SILR-lrule-type &
			  SILR-lrule.
			  
pvp-lrule :=
	    stem &
	    post-infl-lrule &
	    fin-verb-flex &
	    slash-intro-sign &
	    [morph  #m,
	     synsem fin-verb-synsem & 
		    [loc [ _third -,
			   cat [ head  #h ,
				 vcomp <>,
				 subj #subj,
				 subcat.list  *eps-undef-nonlocs-synsem-list*
				       ],
			   cont #cont & [hook.index [--tpc tpc-event]],
			   anc anc-inher & [self <! !>,
					    active [list #a1,
						    last #a2],
					    inert <! !>]
                                ],
		     nonloc contains-slash & 
			 [_slash #_sl & <! [cat sp-or-prd-adj-or-non-fin-verb-cat & 
						[drop -, 
						 head #vc-hd & [mod *undef*,
								extra na_or_-,
								top +],
						 vcomp <>,
						 subcat.list  *eps-2-list*
						],
					    cont.hook #hook] !>,
			  _topic-drop -,
			  rel #rel,
			  slash #slash
				 ],
		     v2 #v2
			 ],
	     cle -,
	     lr [basic  na,
		 reorder 'no],
	     ARGS <   [ morph  #m & <! morph-type & [ 
			     head.FIN [E #temo,
				       --tpc tpc-event]
			     ]
				     !>,
			synsem verb-synsem
			       & 
			       [loc [_third +,
				     cat [ head  #h & initial_+_fin-verb-head,
					    vcomp < sp-or-prd-adj-or-non-fin-verb-synsem & 
						    [loc #vcomp & 
							 [cat sp-or-prd-adj-or-non-fin-verb-cat & 
							      [head #vc-hd,
							       vcomp <>,
							       subcat.list  *eps-2-list*
								     ],
							  cont.hook #hook ],
						     nonloc [slash #slash & 
								   singleton-diff-list & 
								   [LIST.FIRST #vcomp & [cat [drop -, 
											      head [extra na_or_-,
												    top +]
												   ],
											 anc anc-inher & 
											     [self [list #a1,
												    last #a1],
											      active [list #a1,
												      last #a2]
												   ] 
											     ]
									       ],
							     _slash #_sl]
						     ]>,
					    subj #subj
						  ],
				      cont #cont & 
					    [ hook.INDEX.E #temo
								  ]
					  ],
				nonloc contains-no-slash & 
				    [rel #rel,
				     slash <! !>],
				v2 #v2
				    ],
			lr [basic  na,
			    reorder 'no
				   ]
			       ]
		      > 
		    ].




non-fin-SILR-lrule :=
		     post-infl-lrule &
		     nonfinal-no-rel-inher-nonloc-lrule & 
		     [morph  #m,
		      synsem non-fin-verb-synsem & 
			     [loc [ cat [ head   #h & 
						 [subj #subj
						       ],
					  auxf #auxf,
					  auxt #auxt,
					  subcat #sc,
					  ucomps #uc,
					  vcomp  #vcomp & *vc-sp-eps-list*
						 ],
				    cont #cont & [hook.index event & [--psv #psv]]
					],
			      v2 #v2
				  ],
		      lr.basic  na,
		      ARGS <   [
	    morph  #m &
	    [ LIST.FIRST.HEAD.fin [--psv #psv,
				   e tam] 
				  ],
				synsem [ loc [ cat [ head   #h,
						     auxf   #auxf,
						     auxt   #auxt,
						     subj   #subj,
						     subcat #sc,
						     ucomps #uc,
						     vcomp  #vcomp
							    ],
					       cont #cont
						   ],
					 v2 #v2
					     ],
				lr.basic  +
	    ]
			       >
			     ].


non-fin-lrule := 
		 post-infl-lrule &
		 clex-lrule-type & [
   morph  #m,
   synsem non-fin-verb-synsem & [
          loc [ cat [ head #h,
                      subcat #sc,
		      ucomps #uc,
                      vcomp  #vcomp & *vc-sp-eps-list*
                    ],
                cont #cont
              ],
          lex #lex,
          phrase #phrase,
          nonloc #nonloc,
          que    #que
          ],
   ARGS <   [ morph #m,
              synsem [ loc [ cat [ head #h,
                                   subcat #sc,
                                   vcomp  #vcomp,
				   ucomps #uc
                                 ],
                             cont #cont
                           ],
                       lex #lex,
                       phrase #phrase,
                       nonloc #nonloc,
                       que    #que
                     ],
              lr.basic  na
            ]
        >
   ].

perfective-non-fin-lrule :=
  non-fin-lrule & [
  synsem ppp-verb-synsem & [
         loc [ cat.head  [  auxf   #auxf,
                            auxt   #auxt
                         ],
               cont [hook [index [e [perfective #perf & +]]]]
             ]
         ],
  morph.LIST.FIRST.HEAD [VFORM ppp-sm],
  args < [synsem.loc [cat [  auxf   #auxf,
                            auxt   #auxt
				    ],
		      cont.hook.index.e [perfective #perf ]
         ]]
	 >
  ].

tensed-non-fin-lrule :=
		       non-fin-lrule & 
		       --tpc-nonloc-reent &
		       [synsem.loc.cont.hook.index.e tam & 
						   [tense no_inh_tense,
						    perfective #p],
			morph <! [head [vform inf-bse-sm,
					fin.e [tense no_inh_tense,
					       perfective #p]]]!>
						   ].

super-pers-passiv-lrule :=
			  --tpc-nonloc-reent &
			  post-infl-lrule &
			  final-no-rel-inher-nonloc-lrule &  [
   morph  #m,
   synsem non-fin-verb-synsem & [ 
          loc [ cat [ head   passive-verb-head & [
                               subj    < saturated-ref-comp-noun-synsem & [
                                         loc [ cat.head [ cas       struc-nom,
                                                          mass-noun #erg-mass-noun,
                                                          prd       #erg-prd
                                                        ],
                                               cont #erg-cont & [hook.index #i],
                                               uniagr n-n-g & [cas struc-nom]
                                             ],
                                          nonloc #erg-nonloc
                                         ]
					 >,
			       aux     #aux,
                               flip    #flip
                               ],
                      vcomp  #vcomp & *vc-sp-eps-list*,
		      ucomps #uc
                    ],
		anc [self <! !>,
		     active <! !>,
		     inert <! !>], 
                cont #cont & [message.psv #i,
			      hook [ index  event & [--psv +,
						   e.stative bool]]] 
              ],
          v2 #v2
          ],
   lr.basic  -,
   ARGS <    
            [
            morph  #m & [ 
                   LIST.FIRST.HEAD [ fin.e tam,
                                     VFORM ppp-sm
                                   ]
                   ],           
            synsem verb-synsem & [ 
                   loc [ cat [ head   ppp-verb-head & [
                                          aux     #aux,
                                          flip    #flip,
                                          passive +
                                        ],
			       subj   < ref-comp-noun-synsem >,
			       vcomp  #vcomp,
			       ucomps #uc], 
                            erg     < saturated-ref-comp-noun-synsem & [
                                      loc [ cat [ head [ mass-noun #erg-mass-noun,
                                                         prd       #erg-prd
                                                       ]
                                                ],
                                            cont #erg-cont
                                          ],
                                      nonloc #erg-nonloc
                                      ]
                                    >,
                          cont #cont
                         ],
                     v2 #v2
                   ],
             lr.basic  + 
            ]
        >
   ].

erg-subtract-lrule-1 := 
   basic-punct-lrule & [
   synsem.loc.cat.subcat.list #rest,
   ARGS <    
            [         
            synsem.loc [ cat.subcat.list < #erg . #rest > ,
                         erg          < #erg >
                       ]
            ]
        >
   ].

erg-subtract-lrule-2 := 
   basic-punct-lrule & [
   synsem.loc.cat.subcat.list <#1 . #rest>,
   ARGS <    
            [         
            synsem.loc [ cat.subcat.list <#1,  #erg . #rest > ,
                         erg          < #erg >
                       ]
            ]
        >
   ].

erg-subtract-lrule-3 := 
   basic-punct-lrule & [
   synsem.loc.cat.subcat.list <#1,#2 .#rest>,
   ARGS <    
            [         
            synsem.loc [ cat.subcat.list < #1, #2, #erg . #rest > ,
                         erg          < #erg >
                       ]
            ]
        >
   ].




non-state-passive-lrule :=
			  basic-punct-lrule &
			  [synsem.loc.cont.hook.index.e.stative -].
			  



erg-subtract-lrule-pp-1 := 
   basic-punct-lrule & [
   synsem.loc.cat.subcat.list < comp-pp-synsem &
                                [ loc [ cat [ head [ pform durch-von-pform
                                                           ], 
                                              _drop -],
                                        cont.hook  [index #ref-subj],
                                        uniagr da-n-g
                                            ]
                                      ] . #rest>,
   ARGS <    
            [         
	    synsem.loc [ cont [hook [index event]],
			 cat [subj <[loc.cont.hook.index #ref-subj]>,
                              subcat.list < #erg . #rest >] ,
                         erg          < #erg >
                       ]
            ]
        >
   ].

erg-subtract-lrule-pp-2 := 
			   basic-punct-lrule & 
			   [synsem.loc.cat.subcat.list < comp-pp-synsem &
							 [loc [cat [head [pform durch-von-pform
										], 
								    _drop -
									 ],
							       cont.hook [index #ref-subj],
							       uniagr da-n-g
								   ]
							      ], #e1 . #rest>,
			    ARGS <[synsem.loc [cat [subj <[loc.cont.hook.index #ref-subj]>,
						    subcat.list < #e1, #erg . #rest >] ,
					       erg          < #erg >
						   ]
					      ]
				  >
						       ].

erg-subtract-lrule-pp-3 := 
			   basic-punct-lrule & 
			   [synsem.loc.cat.subcat.list < comp-pp-synsem &
							 [ loc [ cat [ head [ pform durch-von-pform
										    ], 
								       _drop -
									    ],
								 cont.hook [index #ref-subj],
								 uniagr da-n-g
								     ]
							       ], #e1, #e2 . #rest>,
			    ARGS <[synsem.loc [cat [subj <[loc.cont.hook.index #ref-subj]>,
						    subcat.list < #e1,#e2, #erg  . #rest >] ,
					       erg          < #erg >
						    ]
					      ]
				  >
						       ].




pers-passiv-lrule-1 :=
		      super-pers-passiv-lrule &
		      erg-subtract-lrule-1.


pers-passiv-lrule-2 :=
		      super-pers-passiv-lrule &
		      erg-subtract-lrule-2.

pers-passiv-lrule-3 :=
		      super-pers-passiv-lrule &
		      erg-subtract-lrule-3.


pers-passiv-pp-lrule-1 :=
			 super-pers-passiv-lrule &
			 erg-subtract-lrule-pp-1 &
			 non-state-passive-lrule.

pers-passiv-pp-lrule-2 :=
			 super-pers-passiv-lrule &
			 erg-subtract-lrule-pp-2 &
			 non-state-passive-lrule.

pers-passiv-pp-lrule-3 :=
			 super-pers-passiv-lrule &
			 erg-subtract-lrule-pp-3 &
			 non-state-passive-lrule.



*lrule-adj-non-prd-sign* :=
			 basic-punct-lrule & 
			 nocomma-sign &
			 [synsem [loc [cat.head mod-adj-head,
				       anc anc-inher &
						[self <! !>,
						 active <! !>,
						 inert <! !>]],
				  que <! !>]].

lrule-adj-non-prd-sign :=
			 *lrule-adj-non-prd-sign* &
			 adj-non-prd-sign.


*participle-lrule* :=
		   stem-or-lex-sign &
		   *lrule-adj-non-prd-sign* &
		   constr-unary-type &
		   *mark-undef-nonlocs* &    
		   spell-lrule &
		   [c-cont [RELS <! [LBL #l,
				     PRED prpstn_m_rel,
				     ARG0 #e & [e [tense none],
						--tpc tpc-],
				     MARG #h
				     ] !>,
			    HCONS <! !>],
		    synsem [loc [cat [head mod-participle-head & 
					   [mod  [loc [cat [ head.cas.morph-case #case,
							     spr < [ loc.cat.head.infl [NP-DECL #dtype,
											DEF-AGR #defagr,
											NODEF-AGR #nodefagr
												] ] >
										 ],
						       uniagr #uniagr]]]],
				 cont [hook [index #e,
					     ltop #l],
				       key.lbl #l,
				       modcont isect-modcont & [hook [ltop #l,
								      index.png #png]]]]],
		    lr [lr_inflected -,
			reorder #reorder],
		    morph <! [ HEAD axmorph-head & [ mclass aclass_-u,
						     INFL [decl #dtype,
							   uniagr #uniagr & [cas.morph-case #case,
									     png #png],
							   def-agr #defagr,
							   nodef-agr #nodefagr
								]
					     ]
				    ] !>,
		    args < [synsem verb-synsem & 
				   [loc.cont.hook [ltop #h,
						   index #e & [e [mood no_mood]]]],
			    lr [lr_inflected +,
				reorder #reorder],
			    morph <! [head vmorph-inf-head  ] !>] >].

participle-lrule := *participle-lrule* &
		    lrule-adj-non-prd-sign.


participle-nerg-lrule :=
			participle-lrule &
			[c-cont [RELS <! [PSV #ind ] !>],
			 synsem [ loc [ cat [ head   [subj < #erg >]],
					cont 
					    [ hook [INDEX [--psv +,
							   E [perfective -]]],
					      MODCONT.HOOK [ INDEX #ind,
							     ltop #hand  ] 
						      ]
					    ],
				  nonloc #nl
				      ],
			 ARGS <   [synsem verb-synsem & 
					  [loc [ cat [ head  adjective-infl-verb-head  &
							     [vform ppp-sm],
						       vcomp  <>
							     ],
						 erg    < #erg & 
							  ref-noun-synsem &
							  [ LOC [CONT.hook [ INDEX  #ind & index,
									    ltop #hand ] ]] 
							  >
						     ],
					   nonloc #nl & undef-nonlocs
					       ],
				   lr.basic +
					  ]
				  >
				].

participle-nerg-lrule-1 :=
			  participle-nerg-lrule &
			  erg-subtract-lrule-1.

participle-nerg-lrule-2 :=
			  participle-nerg-lrule &
			  erg-subtract-lrule-2.


participle-nerg-lrule-pp-1 :=
			     participle-nerg-lrule &
			     erg-subtract-lrule-pp-1.

participle-nerg-lrule-pp-2 :=
			     participle-nerg-lrule &
			     erg-subtract-lrule-pp-2.


participle-erg-rule :=
		      participle-lrule & 
		      [
		       synsem [ loc [ cat [ head [subj < #erg >],
					    subcat #adj-subcat
						  ],
				      CONT 
					  [ hook [INDEX [--psv -,
							 E  [perfective +]]],
					    MODCONT.HOOK [ INDEX #ind ,
						      ltop #hand  ]  ]
					  ],
				nonloc #nl
				    ],
		       ARGS < [synsem verb-synsem & 
				      [loc [ cat [ head   adjective-infl-verb-head &
							  [vform ppp-sm],
						   subj   < #erg >,
						   subcat #adj-subcat,
						   vcomp  <>
							  ],
					     erg    < #erg & synsem &
						      [ LOC.CONT.hook [ INDEX #ind,
									ltop #hand ] ] 
						      >
						 ],
				       nonloc #nl & undef-nonlocs
					   ],
			       lr.basic +
				      ]
			      >
			      ].


;; der auszubildende Lehrling 

participle-zu-inf-lrule :=
			  participle-lrule &
			  [c-cont [rels <! [arg0 #e0] !>],
			   synsem [ loc [ cat [ head   [subj < #erg >] 
						       ],
					  cont 
					      [ hook [INDEX #e0 & [--psv +,
							     E tam & [perfective -]]],
						MODCONT.HOOK [ INDEX #ind,
							       ltop #hand  ] ]
					      ],
				    nonloc #nl
					],
			   ARGS <   [synsem verb-synsem & 
					   [loc [ cat [ head   adjective-infl-verb-head & 
							       [vform inf-sm],
							vcomp  <>
							       ],
						  erg    < #erg & 
							   synsem &
							   [ LOC.CONT.hook [ INDEX  #ind,
									     ltop #hand ] ] 
							   >
						      ],
					    nonloc #nl & undef-nonlocs
						],
				     lr.basic +
					   ]
				    >
				  ].

participle-zu-inf-sep-lrule :=
			  *participle-lrule* &
			  [c-cont [rels <! [arg0 #e0] !>],
			   synsem [ loc [ cat [ head   [subj < #erg >], 
						vcomp <[loc.cat.head zu-dummy-head ]>],
					  cont [ hook [INDEX #e0 & [--psv +,
							     E tam & [perfective -]]],
						MODCONT.HOOK [ INDEX #ind,
							       ltop #hand  ] ]
					      ],
				    nonloc #nl
					],
			   ARGS <   [synsem verb-synsem & 
					   [loc [ cat [ head   adjective-infl-verb-head & 
							       [vform inf-or-real-bse-sm],
							vcomp  <>
							       ],
						  erg    < #erg & 
							   synsem &
							   [ LOC.CONT.hook [ INDEX  #ind,
									     ltop #hand ] ] 
							   >
						      ],
					    nonloc #nl & undef-nonlocs
						],
				     lr.basic +
					   ]
				    >
				  ].

			   

;; die den Mann liebende Frau
participle-bse-rule :=
		      participle-lrule &
		      [synsem [ loc [ cat [ head   [subj < #subj >],
					    subcat #subcat,
					    vcomp  #vcomp & *vc-sp-eps-list*
						   ],
				      CONT 
					  [ hook [INDEX [--psv -,
							 E  [perfective -]]],
					    MODCONT.HOOK [ INDEX #ind ,
							   ltop #hand  ]  ]
					  ],
				nonloc #nl
				    ],
		       ARGS <   [synsem verb-synsem & 
					[ loc [ cat [ head   [vform bse-sm],
						      subj   < #subj & synsem &
							       [ LOC.CONT.hook [ INDEX #ind,
										 ltop #hand ] ] 
							       >,
						      subcat #subcat,
						      vcomp #vcomp
							     ]
						    ],
					  nonloc #nl & undef-nonlocs
					      ],
				 lr.basic +
					]
				>
			      ].



participle-noagr-bse-rule :=
			    final-lrule &
			    spell-lrule &
			    [lr [lr_inflected +,
				 reorder #r],
			     morph  <! [head #m] !>,
			     synsem a-v-modifier-synsem &
				    [ loc [ cat [ head.mod.loc.cat.head.subj <#subj>, 
						  subcat #subcat,
						  vcomp  #vcomp & *vc-sp-eps-list*
									     ],
					 CONT #cont     
					     ],
				   nonloc #nl,
				   que #que
				   ],
			     lr.basic -,
   ARGS <   [
            morph  <! morph-type &
		    [ HEAD #m & vmorph-inf-head]
		    
		    !>,
	     synsem verb-synsem & 
	    [ loc [ cat [ head   adjective-infl-verb-head,
			  subj <#subj>,
			  subcat #subcat,
			  vcomp #vcomp 
				 ],
		    cont #cont
			],
	      nonloc #nl & undef-nonlocs,
	      que #que & <! !>
		  ],
	    lr [lr_inflected +,
		reorder #r,
		basic +]
	    ]
	    >
				].

participle-zu-inf-lrule-1 :=
  participle-zu-inf-lrule &
  erg-subtract-lrule-1.

participle-zu-inf-lrule-2 :=
  participle-zu-inf-lrule &
  erg-subtract-lrule-2.


participle-zu-inf-lrule-pp-1 :=
  participle-zu-inf-lrule &
  erg-subtract-lrule-pp-1.


participle-zu-inf-lrule-pp-2 :=
  participle-zu-inf-lrule &
  erg-subtract-lrule-pp-2.


participle-zu-inf-sep-lrule-1 :=
  participle-zu-inf-sep-lrule &
  erg-subtract-lrule-1.

participle-zu-inf-sep-lrule-2 :=
  participle-zu-inf-sep-lrule &
  erg-subtract-lrule-2.


participle-zu-inf-sep-lrule-pp-1 :=
  participle-zu-inf-sep-lrule &
  erg-subtract-lrule-pp-1.


participle-zu-inf-sep-lrule-pp-2 :=
  participle-zu-inf-sep-lrule &
  erg-subtract-lrule-pp-2.





incoh-to-coh-transport-rule :=
			      post-infl-lrule &
			      nonfinal-noninfl-lrule &
                              [synsem [loc [ erg #erg,
					     cat [ head     #h,
						   subj     #subj,
						   ucomps #uc,
                                                   log-subj #lsubj,
						   auxf #auxf
                                                            ],
					     cont [HCONS [LIST  #hcons,
                                                           LAST #last],
						   hook [ltop #hand,
							 index #ind],
						   RELS #liszt,
						   key #key,
						   message #message,
						   modcont.hook #modcont
                                                         ],
                                            adjunction #adj
                                                ],
                                       nonloc #nl,
                                       v2 #v2],
                               ARGS <[synsem [loc [ erg #erg,
						    cat [ head     #h,
                                                          subj     #subj,
							  ucomps #uc,
                                                          log-subj #lsubj,
							  auxf #auxf,
                                                          subcat [
                                                                  last *null* ]],
                                                    cont [HCONS [LIST #hcons,
                                                                  LAST #last],
                                                          hook [ltop #hand,
								index #ind],
                                                          RELS #liszt,
                                                          key #key,
                                                          message #message,
                                                          modcont.hook #modcont
                                                                 ],
                                                    adjunction #adj
                                                                   ],
                                              nonloc #nl,
                                              v2 #v2]]>].


particle-verb-incoh-to-coh-lrule :=  
                                     incoh-to-coh-transport-rule &
                                     [morph  #m,
                                      synsem particle-or-more-verb-synsem &
                                             [loc.cat [vcomp <#vcomp, 
                                                              coherent-complement-verb-synsem &
                                                              [loc [cat [head [mod #mod,
                                                                               v1 #v1,
                                                                               prd #prd,
                                                                               extra na_or_-,
                                                                               top #top,
                                                                               flip #flip,
                                                                               subj #vsubj,
                                                                               aux #aux,
                                                                               log-subj #log-subj,
                                                                               vform #vform,
                                                                               passive #passive
                                                                               ],
                                                                         spr #spr,
                                                                         vcomp <>,
									 subcat.list *cons*,
                                                                         no_adj #no_adj,
                                                                         gf #gf,
                                                                         extra-poss #extra-poss
                                                                              ],
                                                                    cont #cont,
                                                                    coord #coord,
                                                                    adjunction #adjunction,
                                                                    erg #erg],
                                                               nonloc #nonloc,
                                                               que #que,
                                                               lex #lex,
                                                               phrase -,
                                                               v2 #v2,
                                                               ellipse #ellipse,
                                                               lex-complete #lex-complete,
                                                               cat-change #cat-change] >]],
                                      cle -,
                                      lr [reorder 'yes,
                                          basic   +
                                                  ],
                                      ARGS <   [ morph  #m,
                                                 synsem particle_+vc-verb-synsem & 
                                                        [loc.cat [vcomp <#vcomp & particle-synsem>,
								  head initial_+_fin-verb-head,
                                                                  subcat.list <saturated-comp-inf-verb-synsem &
                                                                          [loc [cat [head  [mod #mod,
                                                                                           v1 #v1,
                                                                                           prd #prd,
                                                                                           extra na_or_+,
                                                                                           top #top,
                                                                                           flip #flip,
                                                                                           subj #vsubj,
                                                                                           aux #aux,
                                                                                           log-subj #log-subj,
                                                                                           vform #vform,
                                                                                           passive #passive
                                                                                               ],
                                                                                     spr #spr,
                                                                                     vcomp <>,
                                                                                     no_adj #no_adj,
                                                                                     gf #gf,
                                                                                     extra-poss #extra-poss
                                                                                          ],
                                                                                cont #cont,
                                                                                coord #coord,
                                                                                adjunction #adjunction,
                                                                                erg #erg],
                                                                           nonloc #nonloc,
                                                                           que #que,
                                                                           lex #lex,
                                                                           v2 #v2,
                                                                           ellipse #ellipse,
                                                                           lex-complete #lex-complete,
                                                                           cat-change #cat-change], ... >]],
                                                 lr [reorder 'yes,
                                                     basic   +
                                                             ]]
                                               > ].




incoh-to-coh-lrule := incoh-to-coh-transport-rule & 
                      [morph  #m,
                       synsem verb-synsem & 
                              [loc.cat [vcomp < coherent-complement-verb-synsem &
                                                [loc [cat non-fin-verb-cat & 
                                                          [head [mod #mod,
                                                                 v1 #v1,
                                                                 prd #prd,
                                                                 extra na_or_-,
                                                                 top #top,
                                                                 flip #flip,
                                                                 subj #vsubj,
                                                                 aux #aux,
                                                                 log-subj #log-subj,
                                                                 vform #vform,
                                                                 passive #passive
                                                                     ],
                                                           spr #spr,
							   subcat.list *cons*,
                                                           vcomp <>,
                                                           _drop -,
                                                           drop -,
                                                           no_adj #no_adj,
                                                           gf #gf,
                                                           extra-poss #extra-poss,
                                                           erg-subtr -],
                                                      cont #cont,
                                                      coord #coord,
                                                      adjunction adjunction,
                                                      erg #erg],
                                                 nonloc #nonloc,
                                                 que #que,
                                                 lex #lex,
                                                 phrase -,
                                                 v2 #v2,
                                                 ellipse #ellipse,
                                                 lex-complete #lex-complete,
                                                 cat-change #cat-change]
                                                >]],
                       cle -,
                       lr [reorder 'yes,
                           basic   +
                                   ],
                       ARGS <   [ morph  #m,
                                  synsem verb-synsem & 
                                         [loc.cat [vcomp <>,
                                                   subcat.list <saturated-comp-inf-verb-synsem &
                                                           [loc [cat non-fin-verb-cat & 
                                                                     [head [mod #mod,
                                                                            v1 #v1,
                                                                            prd #prd,
                                                                            extra na_or_+,
                                                                            top #top,
                                                                            flip #flip,
                                                                            subj #vsubj,
                                                                            aux #aux,
                                                                            log-subj #log-subj,
                                                                            vform #vform,
                                                                            passive #passive
                                                                                ],
                                                                      spr #spr,
                                                                      vcomp <>,
                                                                      no_adj #no_adj,
                                                                      gf #gf,
                                                                      extra-poss #extra-poss],
                                                                 cont #cont,
                                                                 coord #coord,
                                                                 erg #erg],
                                                            nonloc #nonloc,
                                                            que #que,
                                                               lex #lex,
                                                            phrase bool,
                                                            v2 #v2,
                                                            ellipse #ellipse,
                                                            lex-complete #lex-complete,
                                                            cat-change #cat-change]
                                                           , ...>]],
                                  lr [reorder 'yes,
                                      basic   +
                                              ]
                                         ] > ].




reorder-lrule :=
		headed-unary-rule & 
		[synsem verb-synsem & 
			[loc [ erg #erg,
			       cat [ head     #h, 
				     subj     #subj,
				     ucomps #uc,
				     log-subj #lsubj,
				     vcomp    #vcomp & *vc-sp-eps-list* ,
				     auxf #auxf
					      ],
			       cont #cont,
			       anc #anc,
			       adjunction #adj
				   ],
			 que #que,
			 nonloc #nl & undef-nonlocs,
			 v2 #v2,
			 lex +,
			 phrase - 
			     ],
		 lr [ lr_inflected #inf,
		      reorder 'no,
		      basic   -
				   ],
		 ARGS <   [morph  <! [head vmorph-head] !>,
			   synsem verb-synsem & 
				  [loc [ anc #anc,
					 erg #erg,
					 cat [ head     #h,
					       subj     #subj,
					       ucomps #uc,
					       log-subj #lsubj,
					       vcomp    #vcomp,
					       auxf #auxf
							],
					 cont #cont,
					 adjunction #adj
					     ],
				   que #que,
				   nonloc #nl,
				   v2 #v2,
				   lex +,
				   phrase -
				       ],
			   lr [lr_inflected #inf,
			       reorder 'yes,
			       basic -
					    ]
				  ]
        >
			].


*constr-lrule* := *lrule* &
		  constr-type &
		  [ SYNSEM.LOC.CONT [ RELS [ list #l1,
					     last #l3 ],
				      HCONS [ list #h1,
					      last #h3] ],
		    C-CONT [ RELS [ list #l1,
				    last #l2 ],
			     HCONS [ list #h1,
				     last #h2] ],
		    ARGS <[synsem.loc.CONT [ RELS [ list #l2,
						    last #l3 ],
					     HCONS [ list #h2,
						     last #h3 ] ]
					   ] > ].

constr-lrule :=
	       clex-lrule-type & 
	       *constr-lrule*.  


card-infl-lrule := 
		   spell-lrule & 
		   lexical-sign &
		   lexical-nonloc-default &
		   basic-punct-lrule &
		   [needs-affix -,
		    lr  [lr_inflected +],
		    synsem #ss & [loc.cont.key [pred card_rel]],
		    morph <! [stem #st,
			      head #h] !>,
		    args < stem &
			   [synsem #ss & [loc.uniagr #agr],
			    morph <! [stem #st,
				      head #h & 
					   cardinal & 
					   [uniagr #agr]]!>]>].

zu-ord-infl-lrule := 
		     spell-lrule & 
		     lexical-nonloc-default &
		     lexical-sign &
		     [needs-affix +,
		      lr lr-syntax,
		      synsem #ss & [loc.cont.key [pred card_rel]],
		      morph <! [head #h] !>,
		      args < lexical-sign &
			     [synsem #ss,
			      lr lr-lexicon & [lr_inflected +],
			      morph <! [head #h & cardinal ] !> ]>].



ord-infl-lrule :=
		 spell-lrule &
		 stem &
		 lexical-nonloc-default &
		 adj-flex &
		 basic-punct-lrule &
		 [needs-affix +,
		  lr [lr_inflected -],
		  synsem ordinal-number-synsem-syn &
			      [loc #loc & [uniagr #agr,
					   cont.key [pred ord_rel]],
			       nonloc #nl],
		  morph <! [head  amorph-head & [infl.uniagr #agr,
						cpr pos-infl ]] !>,
		  args <[lr [lr_inflected -],
			 morph <! [head cardinal] !>,
			 synsem [loc #loc,
				 nonloc #nl] ]>].

complex-card-ord-lrule := 
		      spell-lrule &
		      basic-punct-lrule &
		      *constr-lrule* &
		      stem &
		      lexical-nonloc-default &
		      [needs-affix +,
		       morph <! [head cardinal] !>,
		       lr [lr_inflected -],
		       synsem.loc [cont [modcont [hook [ltop #l,
							index #x]],
					 key #k,
					 hook [ltop #l,
					       index #ev,
					       xarg #x]]],
		       c-cont [rels <! #k & 
				     [pred #pred & card_or_ord_rel,
				      arg1 #x,
				      carg string,
				      arg0 [e no_tam]],
				     [lbl #l,
				      arg0 #ev & event & [e no_tam],
				      arg1 #x ] !>,
			       hcons <! !>],
		       args <[lr [lr_inflected -],
			      morph <! [head cardinal] !>,
			      synsem.loc [cont [hook [index event & [e no_tam]],
					     key.pred #pred, 
						 modcont.hook [index #x]]]]>].

card-ord-std-linking-lrule := 
			  *constr-lrule* &
			  basic-punct-lrule &
			      [c-cont [rels <! [LBL #l3], [ARG2 #l2,
							   ARG3 #l3]!>],
			       args <[synsem.loc [cont [hook.ltop #l2]]] >].
card-ord-inv-linking-lrule := 
			  *constr-lrule* &
			  basic-punct-lrule &
			      [c-cont [rels <! [LBL #l2], [ARG2 #l2,
							   ARG3 #l3]!>],
			       args <[synsem.loc [cont [hook.ltop #l3]]] >].

complex-times-card-ord-lrule := 
			    complex-card-ord-lrule & 
			    card-ord-std-linking-lrule &
			    [morph <! [head.region above-thousand] !>,
			     c-cont [rels <! [], [pred "times_rel"] !>],
			     synsem.loc [cat #cat,
					 uniagr #agr],
			     args <[morph <! [head.region below-thousand] !>,
				    synsem.loc [cat #cat,
						uniagr #agr]]>].

complex-plus-card-ord-lrule := 
			   complex-card-ord-lrule & 
			   [morph <! [head.region #reg] !>,
			    c-cont [rels <! [], [pred "plus_rel"] !>],
			    synsem.loc [cat #cat,
					uniagr #agr],
			    args <[morph <! [head.region #reg] !>,
				   synsem.loc [cat #cat,
					       uniagr #agr]]>].


complex-times-card-lrule := 
			   complex-times-card-ord-lrule &
			   [morph <! [head cardinal & [uniagr c-p-g]] !>,
			    args <[synsem cardinal-number-synsem-syn]>,
			    c-cont.rels.list <[pred card_rel], ...>].

general-complex-plus-card-lrule := 
			   complex-plus-card-ord-lrule &
			   [morph <! [head cardinal & [uniagr c-p-g]] !>,
			    args <[synsem cardinal-number-synsem-syn]>,
			    c-cont.rels.list <[pred card_rel], ...>].

complex-times-ord-lrule := 
			   complex-times-card-ord-lrule &
			   [synsem ordinal-number-synsem-syn,
			    args <[synsem ordinal-number-synsem-syn]>,
			    c-cont.rels.list <[pred ord_rel], ...>].

general-complex-plus-ord-lrule := 
			   complex-plus-card-ord-lrule &
			   [synsem ordinal-number-synsem-syn,
			    args <[synsem ordinal-number-synsem-syn]>,
			    c-cont.rels.list <[pred ord_rel], ...>].

complex-plus-card-lrule := general-complex-plus-card-lrule & 
			   card-ord-std-linking-lrule. 

complex-plus-ord-lrule := general-complex-plus-ord-lrule & 
			  card-ord-std-linking-lrule. 

complex-inv-plus-card-lrule := general-complex-plus-card-lrule & 
			       card-ord-inv-linking-lrule. 

complex-inv-plus-ord-lrule := general-complex-plus-ord-lrule & 
			      card-ord-inv-linking-lrule. 

#|
year-mod-lrule := 
 		  *constr-lrule* &
		  [c-cont [rels <! [PRED "unspec_mod_rel",
				    ARG1 #x,
				    ARG2 #i,
				    ARG0 #e,
				    LBL #t], [PRED "udef_q_rel",
					      ARG0 #i,
					      RSTR #h] !>,
			   hcons <! qeq & [harg #h,
					   larg #l] !>],
		   synsem  det-time-mod-noun-synsem-syn &
			  [loc [cat.spr     < [ loc.cat.drop-det +]>,
				uniagr a-n-g & [cas lex-case],
				cont [modcont isect-modcont & 
					      [hook [index #e,
						     ltop #t]], 
				      hook [index #i,
					    ltop #t,
					    xarg #x] ] 
					     ]
				 ],
		   ARGS < stem & 
			  [synsem.loc.cont [key.pred "yofc_rel",
					    hook [index #i,
						 ltop #l]]]>].
|#
				




general-adj-lrule :=
		    *constr-lrule* &
		    [SYNSEM.loc [cat.ucomps #uc ,
				 cont [key #k,
				       hook.xarg #x]],
		     ARGS < stem-or-lex-sign & 
			    [SYNSEM.loc [cat.ucomps #uc, 
					 cont [key #k,
					       hook.xarg #x]],
			     morph  <! morph-type &
				     [ HEAD amorph-head ] !>
						 ]
			    >
			  ].
adj-lrule :=
	    general-adj-lrule  &
	    [synsem.loc.cat #cat,
	     ARGS <[synsem.loc.cat #cat]>
		    ].


norm-adj-prd-lrule :=
		     adj-lrule &
		     adj-prd-sign & 
		     [synsem.loc.cont [hook.index #i & 
						  [e tam],
				       key.arg0 #i]].

norm-adj-non-prd-lrule :=
			 adj-lrule &
			 constr-lrule & 
			 [synsem.loc [cat [ucomps <>,
					   head adj-head & [prd -],
					   extra-poss x_-],
				      cont [hook [index #i & 
							event & [e [tense none,
								    mood no_mood]]],
					    key.arg0 #i]],
			  args <[LR [LR_INFLECTED +]]>].




adj-pos-lrule :=
		adj-lrule & 
		[synsem.loc.cont [hook.ltop #l,
				  modcont #mod],
		 args <[synsem.loc.cont [hook.ltop #l,
					 modcont #mod]]>,
		 c-cont [rels <! !>, 
			 hcons <! !>]].

adj-pos-flex-lrule :=
  adj-pos-lrule & [
  MORPH <! [ head.cpr pos-infl         
           ] 
         !>
  ].


adj-comp-lrule :=
		 adj-lrule & 
		 [synsem.loc.cont [key #key,
				   hook [ltop #t,
					 lbot #b],
				   modcont [--scopal #scop,
					    hook [index #i,
						  ltop #t]]],
		  c-cont [hcons <! !>,
			  rels <! [pred "comp_rel",
				   lbl #l,
				   arg0 event & [e no_tam],
				   arg1 #arg] !>],
		  args <[synsem.loc.cont [modcont [--scopal #scop,
						   hook.index #i],
					  key #key & [arg0 #arg & event,
						      lbl #l],
					  hook [ltop #t,
						lbot #b]] ]>,
		  MORPH <! [ head.cpr comp
				      ] 
			 !>
			 ].


adj-comp-flex-lrule :=
		      adj-comp-lrule & 
		      [ARGS <[synsem.loc.cont.key.arg0 event & [e no_tam]] >,
		       MORPH <! [ head.cpr comp-infl] !>].



adj-super-lrule :=
		  adj-lrule & 
		  [synsem.loc.cont [key #key, 
				    hook [ltop #t,
					  lbot #b],
				    modcont [--scopal #scop,
					     hook [index #i,
						   ltop #l]]],
		   c-cont [hcons <! !>,
			   rels <! [pred "super_rel",
				    lbl #l,
				    arg0 event & [e no_tam],
				    arg1 #arg] !>],
		   args <[synsem.loc.cont [modcont [--scopal #scop,
						    hook [index #i]], 
					   hook [ltop #t, lbot #b], 
					   key #key & 
						   [arg0 event & #arg ,
						    lbl #l]] ]>,
		   MORPH <! [ head.cpr super] !>].

adj-super-flex-lrule :=
		       adj-super-lrule & 
		       [ARGS <[synsem.loc.cont.key.arg0 event & [e no_tam]] >,
			MORPH <! [ head.cpr super-infl] !>].


norm-adj-prd-lrule-pos :=
			 norm-adj-prd-lrule & 
			 adj-pos-lrule  &
			 constr-lrule &
			 [ARGS <[LR.LR_INFLECTED +]>,
			  MORPH <! [ head amorph-head & 
					  [CPR uninfl]         
					  ] 
				 !>,
			  SYNSEM.lex-complete +].


norm-adj-prd-lrule-comp :=
			  norm-adj-prd-lrule &
			  adj-comp-lrule & 
			  [MORPH <! [ HEAD ax-comp-null
					   ]
				  !>,
			   SYNSEM.lex-complete +].


norm-adj-prd-lrule-sup :=
  norm-adj-prd-lrule &
  comparable-sign    & 
  adj-super-lrule & [
  MORPH <! [ HEAD ax-super-null ]
         !>,
  SYNSEM.lex-complete -
  ].
 


norm-adj-non-prd-lrule-pos :=
			     norm-adj-non-prd-lrule & 
			     [SYNSEM #ss,
			      MORPH #morph & <! [head.cpr infl ] !>,
			      LR lr-syntax,
			      ARGS <[SYNSEM #ss,
				     MORPH #morph ]>].

;			     adj-pos-flex-lrule.

norm-adj-non-prd-lrule-comp :=
			      norm-adj-non-prd-lrule &
			      adj-comp-flex-lrule.

adj-inflr :=
	    spell-lrule &
	    basic-punct-lrule & 
	    lexical-sign &
	    lexical-nonloc-default &
	    inher-nonloc &
	    [SYNSEM #synsem &
		    [loc.anc [active <! !>,
			      self <! !>,
			      inert <! !>]],
	     morph.list <[head #mhd,
			  STEM #st,
			  --STEM #st
			       ], ... >,
	     LR [ LR_INFLECTED +,
		  LR_STEM -,
		  basic #basic],
	      ARGS < stem-or-lex-sign & 
		     [SYNSEM #synsem,
		      morph.list <[head #mhd
					], ... >,
		      lr [ lr_inflected -,
			   basic #basic
					]
			     ] >
		    ].

	    
adj-comp-inflr :=
		 adj-comp-lrule &
		 spell-lrule &
		 stem-or-lex-sign &
		 inher-nonloc &
		 [signpunct #sp,
		  morph <! [head #head ] !>,
		  SYNSEM.LOC.UNIAGR #agr,
		  LR [LR_INFLECTED -],
		  ARGS <[signpunct #sp,
			 SYNSEM.LOC.UNIAGR #agr,
			 morph <! [head #head ] !>,
			 LR [LR_INFLECTED -]]>].

		 
norm-adj-non-prd-lrule-sup :=
			     norm-adj-non-prd-lrule &
			     comparable-sign    & 
			     adj-super-flex-lrule.


adj-super-inflr :=
		  adj-super-lrule &
		  spell-lrule &
		  stem-or-lex-sign &
		  inher-nonloc &
		  [signpunct #sp,
		   morph <! [head #head ] !>,
		   SYNSEM.LOC.UNIAGR #agr,
		   LR [LR_INFLECTED -,
		       BASIC na_or_-],
		   ARGS <[signpunct #sp,
			  morph <! [head #head ] !>,
			  SYNSEM.LOC.UNIAGR #agr,
			  LR [LR_INFLECTED -]]>].


adj-prd-super-inflr :=
		      norm-adj-prd-lrule-sup &
		      spell-lrule.



adv-lrule := 
	     constr-lrule & 
	     mod-adv-sign &
	     [synsem [lex-complete +,
		      loc [cont [key #k],
			   cat #cat]],
	      args <[synsem [lex-complete +,
			     loc [cont [key #k],
				  cat #cat]]]>].

adv-pos-lrule := adv-lrule & 
		 [synsem.loc [cont [hook #hook,
				    modcont #m]],
		  c-cont [hcons <! !>,
			  rels <! !>],
		  args <[synsem.loc.cont i-sect-adv-basic-sem-type & 
					 [hook #hook,
					  modcont #m]]>,
		  morph <! [ head px-adv-or-ax-pos-null-or-vx-sup-perf] !>].


adv-comp-lrule :=
		 adv-lrule & 
		 [synsem.loc.cont [hook [ltop #l,
					 xarg #xarg],
				   modcont [--scopal #scopal,
					    hook [index #i,
						 ltop #l]]],
		  c-cont [hcons <! !>,
			  rels <! [pred "comp_rel",
				   lbl #l,
				   arg0 event & [e no_tam],
				   arg1 #arg] !>],
		  args <[synsem.loc.cont i-sect-adv-basic-sem-type &
					 [hook.xarg #xarg,
					  modcont [--scopal #scopal,
						   hook.index #i],
					  key [lbl #l,
					       arg0 #arg]] ]>,
		  MORPH <! [ head amorph-head & [mclass aclass, 
						 cpr comp]
				      ] 
			 !>
			 ].




adv-flex-lr := 
	       clex-id-lrule & 
	       mod-adv-sign.


adv-flex-lr-0 := 
		 adv-flex-lr & 
		 [SYNSEM [ LOC.CONT i-sect-adv-sem-type &
				    [ hook [INDEX #ind1,
					    LTOP #hand1],
				      MODCONT.HOOK 
					   [ INDEX #ind1,
					     ltop #hand1]],
			   lex-complete +
				    ]].


adv-flex-lr-0-0 := 
  adv-flex-lr-0 & [
  MORPH <! [ head px-adv-or-ax-pos-null ] !>].



adv-flex-lr-0-2 := 
  adv-flex-lr-0 & [
  MORPH <! [ head vx-sup-perf ] !> ].

adv-flex-lr-1 := 
  adv-flex-lr & [
  MORPH <! [ head amorph-head & [mclass aclass, 
                  CPR comp
                  ]           
           ] 
         !>,
  SYNSEM [ LOC.CONT i-sect-adv-sem-type &
                           [ HOOK [INDEX #ind2,
				   LTOP #hand2],
                             MODCONT.HOOK [ INDEX #ind2,
					    ltop #hand2]],
               lex-complete +
           ]
  ].

adv-flex-lr-2 := 
  adv-flex-lr & [
  MORPH <! [ head amorph-head &
                       [ mclass aclass,
			 CPR   super,
                         INFL  [
                               UNIAGR.PNG p-p-g,
                                DECL 'we
                               ]
                       ]
           ] !>,
  SYNSEM [ LOC [ CONT i-sect-adv-sem-type &
                           [ hook [INDEX #ind3,
				   ltop #hand3],
                             MODCONT.HOOK [ INDEX #ind3,
					    ltop #hand3 ]] 
                ],
        lex-complete -

        ]
].


pers-passiv-pp-lrule :=
   final-no-rel-inher-nonloc-lrule & [
   morph  #m,
   synsem non-fin-verb-synsem & [ 
          loc [ cat [ head   passive-verb-head & 
			     [subj < saturated-ref-comp-noun-synsem & [
					 loc [ cat.head [ cas       struc-nom,
							  mass-noun #erg-mass-noun,
							  prd       #erg-prd
								    ],
					       cont #erg-cont,
					       uniagr n-n-g & [cas struc-nom]
							],
								       nonloc #erg-nonloc
					 ]
                                       >,
			      aux     #aux & -
				   ],
		      ucomps #uc,
		      subcat.list *cons* & [
			     FIRST comp-pp-synsem &
			     [ loc [ cat [ head [ pform durch-von-pform
							], 
					   _drop -
						],
				     cont.hook.index #ref-subj,
                                           uniagr da-n-g
					 ]
				   ]
                             ],
		      vcomp  #vcomp
			     ],
		cont #cont ],
				  nonloc #nl,
				  v2 #v2
	  ],
   lr.basic  -,
				      ARGS <   
					       [
            morph  #m & 
            [ LIST.FIRST.HEAD [ fin.e [tense no_tense],
                                VFORM ppp-sm
                              ]
            ],           
            synsem verb-synsem & [ 
                   loc [ cat [ head   ppp-verb-head & 
				      [aux     #aux,
				       passive +
                                        ],
                               subj   < [ loc.cont.hook.index #ref-subj & ref-ind] >,
			       ucomps #uc,
                               vcomp  #vcomp & *vc-sp-eps-list*
                               ],
                                          erg    < saturated-ref-comp-noun-synsem & [ 
                                                   loc [ cat [ head [ mass-noun #erg-mass-noun,
                                                                      prd       #erg-prd
                                                                    ]
                                                             ],
                                                         cont #erg-cont
                                                       ],
                                                   nonloc #erg-nonloc
                                                   ]
                                                 >,
                          cont #cont & [hook.index event & [--psv +,
						       e.stative -]]
                         ],
                     nonloc #nl,
                     v2 #v2
                  ],
            lr.basic  +
            ]
        >
   ].





super-unpers-passiv-pp-lrule :=
			       --tpc-nonloc-reent &
			       final-no-rel-inher-nonloc-lrule & 
			       [morph  #m,
				synsem non-fin-verb-synsem & 
				       [loc [ cat [ head   passive-verb-head & 
							   [subj    <>,
							    aux     #aux & -
								    ],
						    ucomps #uc,
						    vcomp  #vcomp & 
							   *vc-sp-eps-list*],
					      cont #cont & 
						  [hook.index event & 
							 [--psv +,
							  e.stative -]]
						  ],
					v2 #v2
					    ],
				lr.basic  -,
				ARGS <   [morph  #m & 
						 <![ HEAD [ fin.e [tense no_tense],
							    VFORM ppp-sm
								  ]
							  ]!>,           
					  synsem verb-synsem & 
						 [loc [cat [head   ppp-verb-head &
								   [aux     #aux ,
								    subj   < [ loc.cont.hook.index  #i & ref-ind &
												    [sort agentive
													  ]
												    ] >],
							    subcat.list <[],...>,
							    ucomps #uc,
							    vcomp  #vcomp
								   ],
						       cont #cont & 
							   [key [arg1 #i]]
							   ],
						  v2 #v2
						      ],
					  lr.basic +
						 ]
					 >
				       ].


insert-pp-1 := 
   lrule & [
   synsem.loc.cat.subcat.list < comp-pp-synsem &
                                [ loc [ cat [ head [ pform durch-von-pform
                                                           ], 
                                              _drop -
                                                   ],
                                        cont.hook [index #ref-subj ],
                                        uniagr da-n-g
                                            ]
                                      ] . #rest>,
   ARGS <    
            [         
            synsem.loc [ cat [head.subj <[loc.cont.hook.index #ref-subj]>,
                              subcat.list  #rest ] ,
                         erg          < >
                       ]
            ]
        >
   ].


insert-pp-2 := 
   lrule & [
   synsem.loc.cat.subcat.list < #e1, comp-pp-synsem &
                                [ loc [ cat [ head [ pform durch-von-pform
                                                           ], 
                                              _drop -
                                                   ],
                                        cont.hook.index #ref-subj,
                                        uniagr da-n-g
                                            ]
                                      ] . #rest>,
   ARGS <    
            [         
            synsem.loc [ cat [head.subj <[loc.cont.hook.index #ref-subj]>,
                              subcat.list < #e1 . #rest >] ,
                         erg          < >
                       ]
            ]
        >
   ].


unpers-passiv-pp-lrule-0 := super-unpers-passiv-pp-lrule & 
			    insert-pp-1 & 
			    [synsem.loc.erg <>].


unpers-passiv-pp-lrule-1 := super-unpers-passiv-pp-lrule & 
			    erg-subtract-lrule-pp-1.


unpers-passiv-pp-lrule-2 := super-unpers-passiv-pp-lrule &
			    erg-subtract-lrule-pp-2.


unpers-passiv-pp-lrule-3 := super-unpers-passiv-pp-lrule &
			    erg-subtract-lrule-pp-3.





state-reflexive-lrule :=
			final-no-rel-inher-nonloc-lrule & 
			[morph  #m,
			 synsem non-fin-verb-synsem & 
				[loc [cat [head passive-verb-head & 
						[subj    #subj & <[loc.cont.hook.index #psv]>,
						 aux     #aux
							 ],
					   vcomp  #vcomp & *vc-sp-eps-list*
						],
				      cont #cont & [message.psv #psv,
						    hook [index  [e.stative +,
								  --psv +]]]
					  ],
				 v2 #v2
				     ],
			 lr.basic  -,
			 ARGS <[morph  #m & 
				       <! [HEAD [fin.e [tense no_tense],
							  VFORM ppp-sm
						       ]
						] !>,           
				synsem verb-synsem & 
				       [loc [ cat [ head   ppp-verb-head & 
							   [aux     #aux
								    ],
						    subj    #subj,
						    vcomp  #vcomp
							   ],
					      erg     < refl-pronoun-synsem &
							[loc.cont.hook.index #psv]>,
					      cont #cont],
					v2 #v2
					    ],
				lr.basic +
				       ]
			       >
				].

state-reflexive-lrule-1 :=
			  state-reflexive-lrule &
			  erg-subtract-lrule-1.

;[nk] Substantive, die eine Infinitivphrase subkategorisieren, verlangen nur dann unbedingt ein Komma, wenn die Infinitivphrase erweitert ist. 
;Daher lasse ich standardmäßig eine "nackte" Infinitivphrase auf der Subcat-Liste von inf-count-noun-LEs und lasse die Kommata um die Inf-Phrase 
;herum optional. - "Er hat die Gelegenheit zu schlafen" - "Er hat die Gelegenheit, zu schlafen." 
;Die folgende Regel nimmt ein solches inf-count-noun-le und wandelt seine Subcat-Liste so um, dass eine erweiterte Inf-Phrase verlangt
;wird, Kommata aber diesmal obligatorisch sind: "Er hatte die Gelegenheit, ihm zu helfen." - *"Er hatte die Gelegenheit ihm zu helfen."
;Der Rest wird perkoliert.

subcat-transport-unary-lrule := unary-rule &
				[ SYNSEM.LOC.CAT.SUBCAT <! [ LOC #scloc,
							     NONLOC #scnonloc,
							     QUE #scque,
							     V2 #scv2,
							     LEX-COMPLETE #sclexcomplete,
							     CAT-CHANGE #sccatchange ] !>,
				  ARGS < [ SYNSEM.LOC.CAT.SUBCAT <! [ LOC #scloc,
								      NONLOC #scnonloc,
								      QUE #scque,
								      V2 #scv2,
								      LEX-COMPLETE #sclexcomplete,
								      CAT-CHANGE #sccatchange ] !> ] > ].
				
					 

count-noun-bare-inf-to-extended-inf-lrule_min := spell-lrule & 
						 stem-or-lex-sign &
						 subcat-transport-unary-lrule &
  [ NEEDS-AFFIX -,
    LR #lr,
    MORPH #morph,
    SYNSEM 
	   [ LOC [ CAT [ SUBCAT <! [LEX -,
				    PHRASE + ] !>,
			 HEAD #hd,
			 SUBJ #subj,
			 SPR #spr,
			 VCOMP #vcomp ],
		   UNIAGR #uniagr,
		   CONT #cont,
		   ADJUNCTION #adj,
		   SGF #sgf,
		   ANC #anc,
		   COORD #coord ], 
	     NONLOC #nonlocal,
	     QUE #que,
	     LEX #lex,
	     PHRASE #phrase,
	     V2 #v2,
	     LEX-COMPLETE #lex-complete ],
    ARGS <  inf-count-noun-le & [ 
             LR #lr,
	     MORPH #morph,
             SYNSEM [ LOC [ CAT [ SUBCAT <! [LEX +,
					     PHRASE - ] !>,
				  HEAD #hd,
				  SUBJ #subj,
				  SPR #spr,
				  VCOMP #vcomp ],
			    UNIAGR #uniagr,
			    CONT #cont,
			    ADJUNCTION #adj,
			    SGF #sgf,
			    ANC #anc,
			    COORD #coord], 
		      NONLOC #nonlocal,
                      QUE #que,
 	              LEX #lex,
                      PHRASE #phrase,
	              V2 #v2,
                      LEX-COMPLETE #lex-complete ] 
           ] > 
   ].    

count-noun-bare-inf-to-extended-inf-lrule := count-noun-bare-inf-to-extended-inf-lrule_min & basic-punct-lrule &
					     [ SYNSEM.LOC.CAT.SUBCAT <! [ PUNCT.--LEFT_SISTER_RPUNCT advers_comma_punct_min ] !> ].

rp-pron-synsem-sem-rule-type := 
				*constr-unary-lrule* &
				[morph <! [head #h] !>,
				 lr [basic -],
				 c-cont [rels <! quant-rel &
					       [ LBL #t,
					    arg0 #i],
					  abstr_nom_rel & 
					  [
					   arg0 #i,
					   pred "abstr_nom_rel"] !> ],
			    synsem pron-comp-pp-synsem & 
				   pronominal-synsem & 
				   [loc [uniagr #agr,
					 cont.hook [LTOP #t,
						  INDEX #i]]],
			    args <[morph <! [head #h] !>,
				   lr [basic +],
				   synsem.loc [uniagr #agr]]>].

rp-da-pron-type :=
		 rp-pron-synsem-sem-rule-type &
		 [c-cont [rels <! 
				[ PRED "_jen_q_rel"],
				[] !>]].

rp-hier-pron-type :=
		 rp-pron-synsem-sem-rule-type &
		 [c-cont [rels <! 
				[ PRED "_dies_q_rel"],
				[] !>]].

rp-pron-slash-rule-type :=
			  rp-da-pron-type &
			  rp-in-slash-sign &
			  basic-punct-lrule &
			  spell-lrule &
			  [synsem.loc.cat [head #head,
					   subcat.list  < >],
			   args <comp-prep-le & 
				 [synsem.loc [cat [head #head,
						   subcat.list  < [] > ]]]>].


rp-da-pron-full-rule-type :=
			    sign &
			    rp-da-pron-type &
			    basic-punct-lrule &
			    spell-lrule &
			    stem-or-lex-sign &
			    [synsem [loc.cat [head #head,
					   subcat.list  < >],
				  nonloc undef-nonlocs],
			  args <comp-prep-le & 
				[synsem.loc [cat [head #head,
						  subcat.list  < [] > ]]]>].

rp-hier-pron-full-rule-type :=
			      sign &
			      rp-hier-pron-type &
			      basic-punct-lrule &
			      spell-lrule &
			      stem-or-lex-sign &
			      [synsem [loc.cat [head #head,
						subcat.list  < >],
				       nonloc undef-nonlocs],
			       args <comp-prep-le & 
				     [synsem.loc [cat [head #head,
						       subcat.list  < [] > ]]]>].

super_basic_punctuation_rule := lexical-sign & spell-lrule & 
  [ KEY-ARG #keyarg,	
    ROOT #root,
    VF #vf,
    POSS-AFF #poss-aff,
    SIGNPUNCT [ RPUNCT.PUNCTACCURACY #punctacc & considerpunct ],
    MORPH.LIST.FIRST.--STEM #stem,
    ARGS <  [ 
	     KEY-ARG #keyarg,
             ROOT #root,
             VF #vf,
             POSS-AFF #poss-aff,
	     SIGNPUNCT.RPUNCT.PUNCTACCURACY #punctacc,
	     MORPH.LIST.FIRST.--STEM #stem
           ] >
   ].

basic_punctuation_rule := super_basic_punctuation_rule &
			  [ SYNSEM #synsem,
			    ARGS < [ SYNSEM #synsem ] > ].

punctuation_affix_rule := super_basic_punctuation_rule &
			  stempunct &
			  [ NEEDS-AFFIX +,
			    LR [ P #p,
				 LR_INFLECTED #lri & +,
				 LR_STEM #stem,
				 U #u,
				 BASIC #b,
				 REORDER #reo,
				 ITERATE #it ],
			    MORPH.LIST.FIRST.HEAD #hd,
			    ARGS < [ LR [ P #p,
					  LR_INFLECTED #lri,
					  LR_STEM #stem,
					  U #u,
					  BASIC #b,
					  REORDER #reo,
					  ITERATE #it,
					  PUNCT-LR-ARG punct-lr-arg ],
				     MORPH.LIST.FIRST.HEAD #hd,
				     MALRULE.MAL-COMMA-INFL - ] > ].

punctuation_suffix_rule := punctuation_affix_rule &
			   [ ARGS < [ LR.PUNCT-LR-ARG suffix-lr-arg ] > ].

punctuation_no_affix_rule := basic_punctuation_rule &
			     [ NEEDS-AFFIX -,
			       LR [ lr_STEM -,
				    LR_INFLECTED + ] ].

punctuation_no-affix-rule2 := basic_punctuation_rule &
			      stempunct &
			      [ NEEDS-AFFIX -,
                                LR [ P #p,
				     LR_INFLECTED #lri,
				     U #u,
				     BASIC #b,
				     REORDER #reo,
				     ITERATE #it ],
				ARGS < [ LR [ P #p,
					      LR_INFLECTED #lri,
					      U #u,
					      BASIC #b,
					      REORDER #reo,
					      ITERATE #it,
					      PUNCT-LR-ARG suffix-lr-arg ] ] > ].

punctuation_possib_sent_fin_rule := 
				    basic_punctuation_rule &
				    [ ARGS < [ SYNSEM.LOC.CAT.HEAD possib-sent-final-head ] > ].

basic_punctuation_period_rule := basic_punctuation_rule &
  [ SIGNPUNCT [ LPUNCT #lpunct,
                RPUNCT period_punct_min & [ MSGPRED punct_prop_imp_m_rel ],
		PAIRED ppair_min ],
    ARGS < [ SIGNPUNCT [ LPUNCT #lpunct ] ] > ].

punctuation_period_rule := basic_punctuation_period_rule &
			   punctuation_suffix_rule &
			   punctuation_possib_sent_fin_rule &
			  [ SIGNPUNCT.PAREN #paren,
			    ARGS < [ SIGNPUNCT.PAREN #paren ] > ].


;[nk] abbrev_to_period_punct rule "verwandelt" Abkürzungspunkte am Satzende in Satzpunkte.
;"Er sah den Mann, die Frau usw."
word_dot_to_period_punct_rule :=  basic_punctuation_period_rule &
				  punctuation_no_affix_rule &
				  [ MORPH #morph,
                                    ARGS < dotted_sign & [ MORPH #morph ] > ].


basic_punctuation_excl_rule := punctuation_suffix_rule &
			       punctuation_possib_sent_fin_rule &
  [ SIGNPUNCT [ LPUNCT #lpunct,
                RPUNCT qmark_or_excl_mark_min,
		PAREN #paren ],
    ARGS < [ SIGNPUNCT [ LPUNCT #lpunct,
			 PAREN #paren ]] > ].

init_punctuation_excl_rule := basic_punctuation_excl_rule &
			      [ SIGNPUNCT.RPUNCT.MSGPRED punct_prop_imp_m_rel,
                                ARGS < [ SIGNPUNCT.RPUNCT no_punct_min ] > ].

recursive_punctuation_excl_rule := basic_punctuation_excl_rule &
				   [ SIGNPUNCT.RPUNCT.MSGPRED #msgpred,
                                     ARGS < [ SIGNPUNCT.RPUNCT qmark_or_excl_mark_min &
								  [ MSGPRED #msgpred ] ] > ].

basic_punctuation_qmark_rule := punctuation_suffix_rule &
				punctuation_possib_sent_fin_rule &
  [ SIGNPUNCT [ LPUNCT #lpunct,
                RPUNCT qmark_or_excl_mark_min & [ MSGPRED punct_int_m_rel ],
		PAREN #paren ],
    ARGS < [ SIGNPUNCT [ LPUNCT #lpunct,
			 PAREN #paren ] ] > ]. 

recursive_punctuation_qmark_rule := basic_punctuation_qmark_rule &
				    [ ARGS < [ SIGNPUNCT.RPUNCT qmark_or_excl_mark_min ] > ].

init_punctuation_qmark_rule := basic_punctuation_qmark_rule &
			       [ ARGS < [ SIGNPUNCT.RPUNCT no_punct_min ] > ].

punctuation_semicol_rule := punctuation_suffix_rule &
			    punctuation_possib_sent_fin_rule &
  [ SIGNPUNCT [ LPUNCT #lpunct,
                RPUNCT semicol_punct_min & [MSGPRED punct_prop_imp_m_rel ],
		PAIRED no_ppair_min,
		PAREN #paren,
		--COORDPAIRED no_ppair_min ],
    ARGS < [ SIGNPUNCT [ LPUNCT #lpunct,
                         RPUNCT no_punct_min,
			 PAREN #paren ] ] > ]. 

super_basic_comma_rule := basic_punctuation_rule &
  [ SIGNPUNCT [ LPUNCT #lpunct,
                RPUNCT comma_punct_min,
		PAIRED no_ppair_min,
		PAREN #paren,
		--COORDPAIRED no_ppair_min,
		INFPUNCT [ --LEFT_INFCOMMA left_inf_comma,
		           --RIGHT_INFCOMMA right_inf_comma ] ],
    ARGS < [ SIGNPUNCT [ LPUNCT #lpunct,
			 RPUNCT no_punct_min,
			 PAREN #paren ] ] > ].

basic_comma_rule := super_basic_comma_rule &
		    punctuation_suffix_rule.

punctuation_comma_rule := basic_comma_rule &
			  [ SIGNPUNCT.PUNCTPAIR ppair_min ].

mal_punctuation_comma_rule := super_basic_comma_rule &
			      punctuation_no-affix-rule2 &
			      [ MORPH #morph,
				ARGS < [ MORPH #morph ] >,
				SIGNPUNCT [ PUNCTPAIR ppair_min ] ].

punctuation_rparen_comma_rule := basic_comma_rule &
				 [ SIGNPUNCT.PUNCTPAIR no_ppair_min ].

punctuation_lparen_rule := basic_punctuation_rule &
			   punctuation_affix_rule &
			    [ SIGNPUNCT [ LPUNCT paren_punct_min,
					  RPUNCT #rpunct & no_punct_min,
					  PAREN #paren,
					  PAIRED #paired,
					  --COORDPAIRED #coordpaired ],
			      ARGS < [ SIGNPUNCT [ RPUNCT #rpunct,
						   PAREN advers_comma_punct_min & #paren,
						   PAIRED #paired,
						   --COORDPAIRED #coordpaired ] ] >].


basic_punct_hyphen_mrs_rule := *constr-unary-lrule* &
			       [ c-cont [rels <![ LBL #t,
						  arg0 #i ] !> ,
					 hcons <! !>],
				 synsem  [loc [ cont [ hook [LTOP #t,
							  INDEX #i ],
						       hcons #hcons ]]],
				 ARGS < [ SYNSEM.LOC.CONT.HCONS #hcons ] > ].

basic_punct_hyphen_rule := punctuation_affix_rule &
			   basic_punct_hyphen_mrs_rule &
			   [ SYNSEM 
				    [ LOC [ CAT [ HEAD #hd,
						  SUBJ #subj,
						  SPR < det-synsem >,
						  UCOMPS #ucomps,
						  SUBCAT #subcat,
						  VCOMP #vcomp,
						  INFLECTED #infl ],
					    ANC #anc ],
				      NONLOC #nonloc,
				      QUE #que,
				      PHRASE #phrase,
				      LPER #lper,
				      RPER #rper,
				      LKEYS #lkeys,
				      PUNCT #punct ],
			     SIGNPUNCT basic_no_sign_punct,
                             ARGS < [ SYNSEM ref-noun-synsem &
					    [ LOC [ CAT [ HEAD #hd,
							  SUBJ #subj,
							  UCOMPS #ucomps,
							  SUBCAT #subcat,
							  VCOMP #vcomp,
							  INFLECTED #infl ],
						    ANC #anc ],
					      NONLOC #nonloc,
					      QUE #que,
					      PHRASE #phrase,
					      LPER #lper,
					      RPER #rper,
					      LKEYS #lkeys,
					      PUNCT #punct ],
				      SIGNPUNCT.RPUNCT non_advers_v2_no_punct_min
					      ] > ].



punct_right_hyphen_rule := basic_punct_hyphen_rule &
			   punctuation_suffix_rule &
			   [ c-cont [rels <! [ PRED "left_hyphen_rel" ] !>] ].


punct_left_hyphen_rule := basic_punct_hyphen_rule &
			  [ SYNSEM.LOC [ UNIAGR #uniagr,
	                                 CAT.SPR #spr ],
                            c-cont [rels <! [ PRED "left_hyphen_rel" ] !> ],
			    ARGS < [ SYNSEM.LOC [ UNIAGR #uniagr,
	                                          CAT.SPR #spr ] ] > ].

punctuation_rparen_rule := basic_punctuation_rule &
			   punctuation_suffix_rule &
			    [ SIGNPUNCT [ LPUNCT #lpunct,
					  RPUNCT paren_punct_min,
					  PAREN paren_punct_min,
					  PAIRED no_ppair_min],
			      ARGS < [ SIGNPUNCT.LPUNCT #lpunct ] > ].

punct-lrule-noarg-lrule := lrule &
			 [ LR.PUNCT-LR-ARG non-punct-lr-arg ].