;;; -*- Mode: Lisp; Coding: utf-8 -*- ;;; HAG (Hausa Grammar) ;;; Author: Berthold Crysmann ;;; 2009 (set-coding-system utf-8) ;;; ;;; First, load a number of LKB-specific settings; typically no need to look ;;; too closely here ;;; (lkb-load-lisp (parent-directory) "Version.lsp" t) (setf *grammar-directory* (parent-directory)) (lkb-load-lisp (this-directory) "globals.lsp") (lkb-load-lisp (this-directory) "user-fns.lsp") (lkb-load-lisp (this-directory) "lkbpatches.lsp") (lkb-load-lisp (this-directory) "checkpaths.lsp") (load-lkb-preferences (this-directory) "user-prefs.lsp") ;;; ;;; Optionally, load a set of irregular morphological patterns ;;; (load-irregular-spellings (list (lkb-pathname (parent-directory) "irregs.tab") (lkb-pathname (parent-directory) "robust.tab") ) ) ;;; ;;; Now the core grammar, which will typically be spread out ;;; across multiple files. The Matrix provides matrix.tdl, ;;; defining most of the matrix types and head-types.tdl, which ;;; contains the intermediate types in the subhierarchy under head ;;; (as they would unnecessarily clutter matrix.tdl). You should ;;; rename my_language.tdl to something appropriate, and enter ;;; language-specific types there. In larger grammars, it is common ;;; to separate out e.g. lexical types from construction types ;;; into distinct files. All files containing types used in ;;; the grammar should be mentioned in the following command. ;;; ;;; (2004-06-08) transfer.tdl includes some types which support ;;; transfer rules. Still under development -- ignore for the ;;; time being. ;;; (read-tdl-type-files-aux (list (lkb-pathname (parent-directory) "matrix.tdl") (lkb-pathname (parent-directory) "head-types.tdl") (lkb-pathname (parent-directory) "fundamentals.tdl") (lkb-pathname (parent-directory) "supra.tdl") (lkb-pathname (parent-directory) "morph.tdl") (lkb-pathname (parent-directory) "pn.tdl") (lkb-pathname (parent-directory) "ruletypes.tdl") (lkb-pathname (parent-directory) "lextypes.tdl") (lkb-pathname (parent-directory) "mtr.tdl") (lkb-pathname (parent-directory) "tmt.tdl") )) (mt:read-transfer-rules (list (lkb-pathname (parent-directory) "trigger.mtr") (lkb-pathname (parent-directory) "reduplication.mtr") ) "generation trigger rules" :task :trigger :recurse nil ) (mt:read-transfer-rules (list (lkb-pathname (parent-directory) "generate.mtr") ) "pre-generation rules" :filter nil :task :generate :edges 200) #| (mt:read-transfer-rules (list (lkb-pathname (parent-directory) "paraphrase.mtr") ) "Mini paraphraser" :filter nil :task :paraphrase :edges 200) |# ;;; ;;; Next, the lexicon itself, instantiating (lexical) types of the grammar ;;; (some grammars with larger lexica organize them into multiple files). ;;; ;(read-cached-lex-if-available ; (lkb-pathname (parent-directory) "lexicon.tdl") ; ) (read-tdl-lex-file-aux (list (lkb-pathname (parent-directory) "lexicon.tdl"))) ;;; For grammars with small lexicons, no need to use a cache file: ;;; Once your lexicon has >1000 words or so, consider using the ;;; cache file: ;(read-cached-lex-if-available (lkb-pathname (parent-directory) "lexicon.tdl")) ;;; ;;; Finally, the grammar rules, lexical rules (given special treatment in the ;;; parser in that they can apply _prior_ to `inflectional' rules), and the ;;; `inflectional' rules themselves (rules with an associated orthographemic ;;; alternation of the surface string). ;;; (read-tdl-grammar-file-aux (lkb-pathname (parent-directory) "rules.tdl")) (read-tdl-lex-rule-file-aux (lkb-pathname (parent-directory) "lrules.tdl")) (read-morph-file-aux (lkb-pathname (parent-directory) "irules.tdl")) ;;; Load tone irules for LKB parsing (not used in generation) (read-morph-file-aux (lkb-pathname (this-directory) "tone-irules.tdl")) ;;; ;;; The `start symbol(s)' of the grammar. ;;; (read-tdl-psort-file-aux (lkb-pathname (parent-directory) "roots.tdl")) ;;; ;;; Optionally, a set of types providing labels for nodes in parse trees ;;; (read-tdl-parse-node-file-aux (lkb-pathname (parent-directory) "labels.tdl")) ;;; ;;; A few more LKB-specific settings, this time for MRS post-processing and ;;; generation; also, we always compute the generation index (while we have ;;; small lexica) in the hope that the generator will be used frequently. ;;; (lkb-load-lisp (this-directory) "mrsglobals.lisp" t) (lkb-load-lisp (parent-directory "www") "setup.lsp" t) ;;; ;;; Matrix-derived grammars often have stable enough semantic ;;; representations that the grammar can usefully be tested ;;; by generating from them. The function index-for-generator() ;;; must be called for generation to be enabled. In grammars with ;;; small lexica, this takes a trivial amount of time. If ;;; generation is not being used regularly, and the indexing ;;; is taking too long, comment out the following. index-for-generator() ;;; can also be run from the expanded LKB top menu, under ;;; Generate. ;;; (mt:read-vpm (lkb-pathname (parent-directory) "semi.vpm") :semi) (index-for-generator) (lkb-load-lisp (this-directory) "mt.lsp" t) ;;; ;;; the Regular Expression Pre-Processor (REPP) is now broken up into quite a ;;; number of files. to ease re-use across the LKB and PET, keep the REPP ;;; configuration in a separate file. ;;; (lkb-load-lisp (parent-directory "rpp") "setup.lsp" t nil) (setf *repp-interactive* '(:preprocessor :char :tone)) ;;; Load a maxent model (mainly for the demo) #+(and :logon :tsdb) (tsdb::read-model (lkb-pathname (parent-directory) "hag.g.mem")) #+(and :logon :tsdb) (setf *unpacking-scoring-hook* #'tsdb::mem-score-configuration) #+:arboretum (and (defparameter *gen-packing-p* nil) (defparameter *gen-first-only-p* t)) #+:arboretum (and (functionp #'ag-score-task) (setf *gen-scoring-hook* #'ag-score-task)) ;;; ;;; The following overwrites the LKB's default for what ;;; appears in the parse input dialog box. Putting a ;;; short list of basic sentences from your language ;;; in that position may be helpful. ;;; (if (eq (length *last-parses*) 1) (setf *last-parses* '( "Allàh yà gaafàrtà maalàm" "Állah ya gáafarta máalam" "Állàh yà gáafàrtà máalàm" "Allah ya gaafarta maalam" "Allah ya gafarta malam"))) ;;; Make sure we have an environment that can display hooked letters. (lkb::lui-shutdown)