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


(defparameter *active-parsing-p* t)

;;; Strings

(defparameter *toptype* '*top*)

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

;;; Lexical files

(defparameter *orth-path* '(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)

;;;
;;; input characters to be ignored (i.e. suppressed) in tokenization
;;;
(defparameter *punctuation-characters*
 (append
  '(#\space #\[ #\] #\{ #\} #\> #\< #\% #\* #\+ #\= #\/ #\- #\")))   

;(defparameter *punctuation-characters*
; (append
;  '(#\space #\! #\" #\& #\' #\(
;     #\) #\* #\+ #\, #\- #\. #\/ #\;
;     #\< #\= #\> #\? #\@ #\[ #\\ #\] #\^
;     #\_ #\` #\{ #\| #\} #\~)))   
  
  
;(defparameter *punctuation-characters*
;  (append
;   '(#\space #\! #\" #\& #\' #\(
;     #\) #\* #\+ #\, #\- #\. #\/ #\;
;     #\< #\= #\> #\? #\@ #\[ #\\ #\] #\^
;     #\_ #\` #\{ #\| #\} #\~)
;   #+:ics
;   '(#\ideographic_full_stop #\fullwidth_question_mark 
;     #\horizontal_ellipsis #\fullwidth_full_stop
;     #\fullwidth_exclamation_mark #\black_circle
;     #\fullwidth_comma #\ideographic_space
;     #\katakana_middle_dot #\white_circle)))

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

;;; Parsing

(defparameter *chart-limit* 100)

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

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

(defparameter *start-symbol* '(root)
  "specifing valid parses")

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

(defparameter *deleted-daughter-features* 
  '(ARGS HEAD-DTR NON-HEAD-DTR DTR)
  "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 NON-LOCAL SLASH LIST FIRST))

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

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

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

;;; for the compare function 

(defparameter *discriminant-path* '(synsem local keys key pred))

;;; the lex-rule suffix defaults to _lex_rule, but this might
;;; not be desirable

(setf *lex-rule-suffix* nil)

(setf cdb::*cdb-ascii-p* nil)

;;;
;;; when running as part of the LOGON tree, users need not have their own local
;;; installation of FreeLing, and we avoid all usages of absolute path names.
;;; thus, ideally, the complete LOGON tree, including the SRG and FreeLing, can
;;; be run on any (reasonably up-to-date) Linux installation, without the need
;;; to install additional, non-standard packages.              (20-sep-07; oe)
;;;
(setf *sppp-application* 
  #+:logon
  (let ((root (getenv "LOGONROOT")))
    (format nil "exec ~a/upf/srg/freeling/sppp" root))
  #-:logon
  "/home/montse/freeling/sppp")

#+:logon
(setf *sppp-coding-system* :iso-8859-1)