;;; -*- Package: LKB; -*-


;;; LinGO grammar specific globals file
;;; parameters only - grammar specific functions 
;;; should go in user-fns.lsp
;;; patches in lkb-code-patches.lsp


#-(or :lkb-v5.3 :lkb-v5.4)
(in-package :cl-user)
#+(or :lkb-v5.3 :lkb-v5.4)
(in-package :lkb)

(defparameter *active-parsing-p* t)

(defparameter *hierarchy-only-p* nil)


;;; increase dag pool size
;;;

(defparameter *dag-pool-size* 200000)
(defparameter *dag-pool*
  (if (and (pool-p *dag-pool*) 
           (not (= (pool-size *dag-pool*) *dag-pool-size*)))
    (create-pool *dag-pool-size* #'(lambda () (make-safe-dag-x nil nil)))
    *dag-pool*))


;;; Strings

(defparameter *toptype* '*top*)

(defparameter *string-type* 'string
   "a special type name - any lisp strings are subtypes of it")

;;; Lexical files

(defparameter *orth-path* '(morph list first stem))


(defparameter *list-tail* '(rest))

(defparameter *list-head* '(first))

(defparameter *empty-list-type* '*null*)

(defparameter *list-type* '*list*)

(defparameter *diff-list-type* '*diff-list*)

(defparameter *diff-list-list* 'list)

(defparameter *diff-list-last* 'last)

(defparameter *lex-rule-suffix* "_INFL_RULE"
 "creates the inflectional rule name from the information
   in irregs.tab - for PAGE compatability")

(defparameter *irregular-forms-only-p* t)

(defparameter *most-specific-only-p* t)

(defparameter *feature-ordering* '(SYNSEM C-CONT MORPH ARGS HEAD-DTR NON-HEAD-DTR))

;;;

(defparameter *display-type-hierarchy-on-load* nil)

;;; Parsing

(defparameter *chart-limit* 100)

(defparameter *maximum-number-of-edges* 12000)

(defparameter *mother-feature* NIL
   "The feature giving the mother in a grammar rule")

(defparameter *start-symbol* '(utterance-v-scnd utterance-v-fst utterance-non-v utterance-turn-seq utterance-coord utterance-int-clause)
   "specifing valid parses")

;(defparameter *start-symbol* '(utterance-v-scnd utterance-v-fst-conj utterance-v-fst-ind utterance-non-v utterance-turn-seq utterance-coord)
;   "specifing valid parses")
;; Use the following for parsing fragments as well as full clauses:
#|
(defparameter *start-symbol* '(root_strict root root_conj root_subord)
  "specifing valid parses including fragments")
|#

(defparameter *maximal-lex-rule-applications* 8
   "The number of lexical rule applications which may be made
   before it is assumed that some rules are applying circularly")

(defparameter *maximal-morphological-rule-depth* 6)


(defparameter *deleted-daughter-features* '(ARGS HEAD-DTR NON-HEAD-DTR head-loc comp-loc mom-subcat)
   "features pointing to daughters deleted on building a constituent")


;;; Parse tree node labels

;;; the path where the name string is stored
(defparameter *label-path* '(LABEL-NAME))

;;; the path for the meta prefix symbol
(defparameter *prefix-path* '(META-PREFIX))

;;; the path for the meta suffix symbol
(defparameter *suffix-path* '(META-SUFFIX))

;;; the path for the recursive category
(defparameter *recursive-path* '(SYNSEM NONLOC SLASH LIST FIRST))

;;; the path inside the node to be unified with the recursive node
(defparameter *local-path* '(SYNSEM LOC))

;;; the path inside the node to be unified with the label node
(defparameter *label-fs-path* '())

(defparameter *label-template-type* 'label-sign)

;;; for the compare function 

(defparameter *discriminant-path* '(list (synsem loc cont key pred) (synsem loc cont key arg0 png pn)))

;;; Hide lexical rule nodes in parse tree
;;; (setf  *dont-show-lex-rules* t)
;;; this belongs in the user-prefs file, not here


(defparameter *chart-dependencies*
    '((SYNSEM LOC CAT HEAD SP-FORM) (SYNSEM LOC CAT VCOMP FIRST LOC CAT HEAD SP-FORM)
;      (SYNSEM LOC CAT VCOMP FIRST LOC CAT HEAD SP-FORM) (SYNSEM LOC CAT HEAD SP-FORM)
      (SYNSEM LOC CAT SUBCAT LIST FIRST LOC CAT HEAD PFORM) (SYNSEM LOC CAT HEAD PFORM)
      (SYNSEM LOC CAT SUBCAT LIST REST FIRST LOC CAT HEAD PFORM) (SYNSEM LOC CAT HEAD PFORM)
;      (SYNSEM LOC CAT VCOMP FIRST LOC CAT HEAD AUXF) (SYNSEM LOC CAT AUXF)
;      (SYNSEM LOC CAT SUBCAT LIST FIRST LOC CAT HEAD V1 CAT VCOMP FIRST LOC CAT HEAD AUXF) (SYNSEM LOC CAT AUXF)
      (SYNSEM LOC CAT HEAD __VC) (SYNSEM LOC CAT VCOMP FIRST LOC CAT HEAD __VC)
      )
  )


(setf *semantics-index-path* '(SYNSEM LOC CONT HOOK INDEX))



(defparameter *chart-packing-p* nil)


;(setf *parse-record* (selectively-unpack-edges *parse-record* 10))


(defparameter *packing-restrictor*
  '(RELS HCONS SLASH _V1 ACTIVE INERT SELF ALTKEY)
  "restrictor used when parsing with ambiguity packing")

(setf *gen-ignore-rules*
  '(nx-d-e_infl_rule
    ;;     pvp-lrule-0 
         pvp-lrule-1
         pvp-lrule-2
         pvp-lrule-3
    ;;     vcomp-slash-intro-0
         vcomp-slash-intro-1
         vcomp-slash-intro-2
         vcomp-slash-intro-3
    ;;     eps-vcomp-slash-intro-part 
    ;;     third-construction 
    particle-verb-incoh-to-coh-lrule-0 
    incoh-to-coh-lrule-0
    ))


(defparameter *duplicate-lex-ids* 
  '(PAS-SEI-IMP GRUESS-DUMMY AUX-SEI-IMP AUX-GEWESEN GEHABT DREIVIERTEL-DUMMY HAB PAS-WERDE-IMP))


(setf mrs::*null-semantics-hack-p* t)

(setf *gen-packing-p* t)

(setf *gen-filtering-p* t)

(setf *gen-equate-qeqs-p* t)


(setf *lex-rule-show-one-step* t)

#+:tsdb
(setf *unpacking-scoring-hook* #'tsdb::mem-score-configuration)



(defparameter *generic-lexical-entries*
    '((named_gle :generate) (card_gle :generate) 
      (ord_gle :generate) (yofc_gle :generate)))



(grammar-encoding 'UTF-8)


(setf *translate-grid* '(:de . (:de :en)))

(setf lkb::*characterize-p* t)

(setf *last-parses* (remove "the dog barks" *last-parses* :test #'string=))
(unless *last-parses* (setf *last-parses* '("Am Anfang war das Wort.")))