;;;   -*- Mode: LISP; Package: CGP; BASE: 10; Syntax: ANSI-Common-Lisp; -*-
;;
;; Copyright (C) Paul Meurer 1999-2004. All rights reserved.
;; paul.meurer@aksis.uib.no
;; Aksis, University of Bergen
;;
;; Constraint Grammar Parser 
;; (See Fred Karlsson et.al.: Constraint Grammar, Mouton de Gruyter 1995)
;;
;; Class definitions

;;-------------------------------------------------------------------------------------
;; TO DO:
;; - Test syntactic mapping and disambiguation
;; - Store morphological rules in hash tables with EQUAL keys instead of nested 
;;   hash tables
;;-------------------------------------------------------------------------------------

(in-package "CGP")

(defclass grammar ()
  ((name :initform nil :initarg :name :accessor name)
   (language :initform nil :initarg :language :reader language)
   (multi-tagger :initform nil :initarg :multi-tagger :reader multi-tagger)
   ))

;; Objects of this class contain all CG functionality. In addition, some administrative
;; information is included.
(defclass constraint-grammar (grammar)
  ((documentation :initform "" :initarg :documentation :accessor cg-documentation) 
   (sentence-delimiters ; (4.)
    :initform nil :accessor sentence-delimiters)
   (set-declarations ; (5.)
    :initform (make-hash-table) :reader set-declarations)
   (encoded-set-declarations
    :initform (make-hash-table) :reader encoded-set-declarations)
   (templates ; (9.6)
    :initform (make-hash-table :test #'equal) :reader templates)
   (syntactic-functions ; (6.)
    :initform (make-hash-table) :reader syntactic-functions)
   (principal-functions ; (7.)
    :initform (make-hash-table) :reader principal-functions)
   (barrier-elements ; (7.)
    :initform (make-hash-table) :reader barrier-elements)
   ;; rules without domain string, comprising disambiguation-constraints (9.),
   ;; heuristic-disambiguation-constraints (10.), syntactic-constraints (12.) and 
   ;; heuristic-syntactic-constraints (13.)
   (rules :initform (make-hash-table) :reader rules)
   ;; the same for rules with domain string
   (domain-rules :initform (make-hash-table :test #'equal) :reader domain-rules)
   (%feature-codes :initform (make-hash-table) :accessor %feature-codes)
   (%domain-feature-codes :initform (make-hash-table :test #'equal) :accessor %domain-feature-codes)
   (%mapping-features :initform t :accessor %mapping-features)
   (%syntactic-function-codes :initform t :accessor %syntactic-function-codes)
   (morphosyntactic-mappings ; (8.)
    :initform (make-hash-table :test #'equal) :reader morphosyntactic-mappings)
   (morphological-heuristics ; (14.)
    :initform (make-hash-table :test #'equal) :reader morphological-heuristics)
   (rule-array :initform (make-array 4000 ; some upper bound on the number of rules is OK. 
                                     :adjustable t :fill-pointer 0)
               :reader rule-array) ; an array containing all rules; used only for debugging
   (careful-p :initform nil :accessor careful-p) ; Global careful mode if = T (9.3.)
   ;; lists the different parsing steps to be applied to a sentence
   (operations :initform nil :initarg :operations :accessor parse-operations)
   (feature-precedence :initform () :initarg :feature-precedence :accessor feature-precedence)
   (group-comments :initform (make-array 4000 :adjustable t :fill-pointer 0) :accessor rule-group-comments)
   ;; some administrative slots
   (creation-date :initform (get-universal-time) :initarg :creation-date :reader creation-date)
   (change-date :initform (get-universal-time) :initarg :change-date :accessor change-date)
   (locked-p :initform nil :initarg :locked-p :accessor cg-locked-p)
   (cg-edit-lock :initform (make-instance 'lock) :reader cg-edit-lock)
   (parent-cg ;; name of the parent cg
    :initform nil :initarg :parent-cg :reader parent-cg)))

;; Used to lock a CG for editing. Noone else than the user who has grabbed the write 
;; lock of a CG may edit that CG.
(defclass lock ()
  ((user :initform nil :initarg :user :accessor user)
   (host :initform nil :initarg :host :accessor host)
   (last-access :initform nil :accessor last-access)))

;; The syntactic rules are indexed by a trie whose nodes (of class CONSTRAINT-NODE)
;; represent rule constraints.
(defclass constraint-node ()
  ((constraint :initform nil :initarg :constraint :reader constraint)
   (parent-constraint :initform nil :initarg :parent :reader parent-constraint)
   (child-constraints :initform () :accessor child-constraints)
   (rules :initform nil :initarg :rules :accessor constraint-rules)))

(defclass rule ()
  ((language :initform nil :initarg :language :reader language)
   (heuristic-level :initform 0 :initarg :heuristic-level :reader heuristic-level) ;; *** not used??
   (target :initform nil :initarg :target :reader rule-target)
   ;; list of lists: ((a b c) (d e f)) => (or (and a b c) (and d e f))
   (constraints :initform nil :initarg :constraints :accessor rule-constraints)
   (boundary-mode :initform nil :initarg :boundary-mode :accessor boundary-mode)
   (frequency :initform 0 :accessor rule-frequency)
   (id :initform nil :initarg :id :reader rule-id)
   (comment :initform nil :initarg :comment :accessor rule-comment)
   ;;(group-comment :initform nil :initarg :group-comment :accessor rule-group-comment)
   (previous-version :initform nil :initarg :previous-version :accessor previous-version)))

(defclass disambiguation-rule (rule)
  ((type :initform nil :initarg :type :reader rule-type)
   (domain :initform nil :initarg :domain :reader rule-domain)))

(defclass syntactic-disambiguation-rule (rule)
  ((type :initform nil :initarg :type :reader rule-type)
   ;; here we differ from Karlsson, who does not allow non-trivial domains 
   (domain :initform nil :initarg :domain :reader rule-domain)))

(defclass mapping-rule (rule)
  ((labels :initform nil :initarg :labels :reader rule-labels)))

(defclass morphological-heuristics-rule (rule)
  ((string-conditions :initform nil :initarg :string-conditions :reader rule-string-conditions)
   (string-changes :initform nil :initarg :string-changes :reader rule-string-changes)))

(defclass strong-select-rule (disambiguation-rule) ())
(defclass select-rule (disambiguation-rule) ())
(defclass discard-rule (disambiguation-rule) ())
(defclass clb-rule (disambiguation-rule) ())
(defclass syntactic-select-rule (syntactic-disambiguation-rule) ())
(defclass syntactic-discard-rule (syntactic-disambiguation-rule) ())

#+duplicate
(defclass regexp-sentence (sentence)
  ((matches :initform () :accessor matches)
   (pending-operations :initform nil :accessor pending-operations)))

;; additional functionality for named entity recognition
(defclass ne-constraint-grammar (constraint-grammar)
  ((named-entity-tags :initform (make-hash-table) :reader named-entity-tags)
   (%named-entity-mapping-features :initform t :accessor %named-entity-mapping-features)
   (%named-entity-tag-codes :initform t :accessor %named-entity-tag-codes)
   (regexp-parser :initform nil :accessor regexp-parser)
   (named-entity-mappings
    :initform (make-hash-table :test #'equal) :reader named-entity-mappings)))

(defclass named-entity-select-rule (syntactic-disambiguation-rule) ())
(defclass named-entity-discard-rule (syntactic-disambiguation-rule) ())
(defclass named-entity-mapping-rule (mapping-rule) ())

:eof