diff options
| -rw-r--r-- | doc/gf-editor-modes.t2t | 7 | ||||
| -rw-r--r-- | src/tools/gf.el | 1351 |
2 files changed, 5 insertions, 1353 deletions
diff --git a/doc/gf-editor-modes.t2t b/doc/gf-editor-modes.t2t index d9368dd32..13b8f718c 100644 --- a/doc/gf-editor-modes.t2t +++ b/doc/gf-editor-modes.t2t @@ -13,9 +13,10 @@ welcome! ==Emacs== -[gf.el ../src/tools/gf.el] by Johan BockgÃ¥rd provides syntax highlighting and -automatic indentation and lets you run the GF Shell in an emacs buffer. -See installation instructions inside. +[gf.el https://github.com/GrammaticalFramework/gf-emacs-mode] by Johan +BockgÃ¥rd provides syntax highlighting and automatic indentation and +lets you run the GF Shell in an emacs buffer. See installation +instructions inside. ==Atom== [language-gf https://atom.io/packages/language-gf], by John J. Camilleri diff --git a/src/tools/gf.el b/src/tools/gf.el index c8ebc9a50..594e0845e 100644 --- a/src/tools/gf.el +++ b/src/tools/gf.el @@ -1,1350 +1 @@ -;;; gf.el --- Major mode for editing GF code -*-coding: iso-8859-1;-*- - -;; Copyright (C) 2005, 2006, 2007 Johan Bockgård -;; Time-stamp: <2007-06-16 11:57:48 bojohan> - -;; Author: Johan Bockgård <bojohan+mail@dd.chalmers.se> -;; Keywords: languages - -;; This file is free software; you can redistribute it and/or modify -;; it under the terms of the GNU General Public License as published by -;; the Free Software Foundation; either version 2, or (at your option) -;; any later version. - -;; This file is distributed in the hope that it will be useful, -;; but WITHOUT ANY WARRANTY; without even the implied warranty of -;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -;; GNU General Public License for more details. - -;; You should have received a copy of the GNU General Public License -;; along with GNU Emacs; see the file COPYING. If not, write to -;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, -;; Boston, MA 02110-1301, USA. - -;;; Commentary: - -;; Major mode for editing GF code, with support for running a GF -;; shell. - -;;; Usage: - -;; To use this library, put it somewhere Emacs can find it (in -;; `load-path') and add the following lines to your .emacs file. - -;; (autoload 'run-gf "gf" nil t) -;; (autoload 'gf-mode "gf" nil t) -;; (add-to-list 'auto-mode-alist '("\\.gf\\(\\|e\\|r\\|cm?\\)\\'" . gf-mode)) -;; (add-to-list 'auto-mode-alist '("\\.cf\\'" . gf-mode)) -;; (add-to-list 'auto-mode-alist '("\\.ebnf\\'" . gf-mode)) - -;;; History: - -;; 2006-10-30: -;; let a = b -;; c = d ... -;; in ... -;; indentation now works (most of the time). - -;;; Code: - -(eval-when-compile (require 'cl)) - -(defgroup gf nil - "Support for GF (Grammatical Framework)" - :group 'languages - ;; :link '(emacs-commentary-link "gf") - :link '(url-link "http://www.cs.chalmers.se/~aarne/GF/")) - -(defvar gf-mode-map - (let ((map (make-sparse-keymap))) - (define-key map "\C-c\C-l" 'gf-load-file) - (define-key map "\C-c\C-b" 'gf-display-inf-buffer) - (define-key map "\C-c\C-s" 'run-gf) - (define-key map (kbd "DEL") 'backward-delete-char-untabify) - map) - "Keymap for `gf-mode'.") - -;; Taken from haskell-mode -(defvar gf-mode-syntax-table - (let ((table (make-syntax-table))) - (modify-syntax-entry ?\ " " table) - (modify-syntax-entry ?\t " " table) - (modify-syntax-entry ?\" "\"" table) - (modify-syntax-entry ?\' "\'" table) - (modify-syntax-entry ?_ "w" table) - (modify-syntax-entry ?\( "()" table) - (modify-syntax-entry ?\) ")(" table) - (modify-syntax-entry ?\[ "(]" table) - (modify-syntax-entry ?\] ")[" table) - ;; (modify-syntax-entry ?\< "(>" table) - ;; (modify-syntax-entry ?\> ")<" table) - - (cond ((featurep 'xemacs) - ;; I don't know whether this is equivalent to the below - ;; (modulo nesting). -- fx - (modify-syntax-entry ?{ "(}5" table) - (modify-syntax-entry ?} "){8" table) - (modify-syntax-entry ?- "_ 1267" table)) - (t - ;; The following get comment syntax right, similarly to C++ - ;; In Emacs 21, the `n' indicates that they nest. - ;; The `b' annotation is actually ignored because it's only - ;; meaningful on the second char of a comment-starter, so - ;; on Emacs 20 and before we get wrong results. --Stef - (modify-syntax-entry ?\{ "(}1nb" table) - (modify-syntax-entry ?\} "){4nb" table) - (modify-syntax-entry ?- "_ 123" table))) - (modify-syntax-entry ?\n ">" table) - - (let (i lim) - (map-char-table - (lambda (k v) - (when (equal v '(1)) - ;; The current Emacs 22 codebase can pass either a char - ;; or a char range. - (if (consp k) - (setq i (car k) - lim (cdr k)) - (setq i k - lim k)) - (while (<= i lim) - (when (> i 127) - (modify-syntax-entry i "_" table)) - (setq i (1+ i))))) - (standard-syntax-table))) - - (modify-syntax-entry ?\` "$`" table) - (modify-syntax-entry ?\\ "\\" table) - (mapcar (lambda (x) - (modify-syntax-entry x "_" table)) - ;; Some of these are actually OK by default. - "!#$%&*+./:=?@^|~") - (unless (featurep 'mule) - ;; Non-ASCII syntax should be OK, at least in Emacs. - (mapcar (lambda (x) - (modify-syntax-entry x "_" table)) - (concat "¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿" - "×÷")) - (mapcar (lambda (x) - (modify-syntax-entry x "w" table)) - (concat "ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ" - "ØÙÚÛÜÝÞß" - "àáâãäåæçèéêëìíîïðñòóôõö" - "øùúûüýþÿ"))) - table) - "Syntax table used in GF mode.") - -;; Lin PType Str Strs Tok Type -;; abstract case cat concrete data def -;; flags fn fun grammar in include -;; incomplete instance interface let lin lincat -;; lindef lintype of open oper out -;; package param pattern pre printname resource -;; reuse strs table tokenizer transfer union -;; var variants where with -;; ; = { } ( ) : -> ** , [ ] - . | % ? < > @ ! * \ => ++ + _ $ / - -;; Judgements -(defvar gf-top-level-keywords - '("cat" "fun" "lincat" "lintype" "lin" "pattern" - "oper" "def" "param" "flags" "lindef" "printname" - "data" "transfer" - )) - -(defvar gf-module-keywords - '("abstract" "concrete" "resource" "instance" "interface")) - -(defvar gf-keywords - (append '("of" "let" "include" "open" "in" "where" - "with" "case" "incomplete" "table" - "variants" "pre" "strs" "overload") - gf-top-level-keywords - gf-module-keywords)) - -(defvar gf-top-level-keyword-regexp (regexp-opt gf-top-level-keywords 'words)) -(defvar gf-keyword-regexp (regexp-opt gf-keywords 'words)) - -(defvar gf-font-lock-keywords - (let ((sym "\\(\\s_\\|\\\\\\)+") - ;; (keyw gf-keyword-regexp) - (mod (concat (regexp-opt gf-module-keywords 'words) - "\\s-\\(\\w+\\)")) - (pface '(if (boundp 'font-lock-preprocessor-face) - font-lock-preprocessor-face - font-lock-builtin-face))) - `(;; Module - (,mod (1 font-lock-keyword-face) - (2 font-lock-type-face)) - ;; Keywords - (,(lambda (end) - (let (parse-sexp-lookup-properties) - (re-search-forward gf-keyword-regexp end t))) - . font-lock-keyword-face) - ;; Operators - (,sym . font-lock-variable-name-face) - ;; Pragmas - ("^--\\(#.*\\)" (1 ,pface prepend)) - ("--\\(#\\s-*\\(notpresent\\|prob\\).*\\)" (1 ,pface prepend)) - ;; GFDoc - ("^--[0-9]+\\s-*\\(.*\\)" (1 'underline prepend)) - ("^--\\([*!.]\\)" (1 'underline prepend)) - (,(lambda (end) - (let (found) - (while - (and (setq found (re-search-forward - ;; "\\$.*?\\$\\|\\*.*?\\*\\|\".*?\"" - "\\$.*?\\$" - end t)) - (not (eq (get-text-property (match-beginning 0) 'face) - 'font-lock-comment-face)))) - found)) - (0 (if (face-italic-p 'font-lock-comment-face) - '((:slant normal)) - '((:slant italic))) - prepend)) - ;; Types (?) - ;; ("[^.]\\(\\<[[:upper:]]\\w*\\)[^.]" 1 font-lock-type-face) - )) - "Keyword highlighting specification for `gf-mode'.") - -(defcustom gf-let-brace-style t - "The let...in style to use for indentaton. - -A value of t means unbraced (new) style: - - - let x = a; - y = b; in ... - -A value of nil means braced (old) style - - let { x = a; - y = b; } in ... - -Anything else means try to guess." - :type '(choice (const :tag "Unbraced" t) - (const :tag "Braced" nil) - (const :tag "Heuristic" 'heuristic)) - :group 'gf) - -;; let x = let a = f; -;; b = g; -;; in b; -;; y = d; -;; in h -(defun gf-match-let/in (let/in end) - (when gf-let-brace-style - (if (eq 'let let/in) - (and (re-search-forward "\\<le\\(t\\)\\>" end t) - (or (eq t gf-let-brace-style) - (save-excursion - (skip-syntax-forward " ") - (not (eq ?\{ (char-after)))))) - (and (re-search-forward "\\<\\(i\\)n\\>" end t) - (or (eq t gf-let-brace-style) - (save-excursion - (backward-char 2) - (skip-syntax-backward " ") - (not (eq ?\} (char-before))))))))) - -(defvar gf-font-lock-syntactic-keywords - `(;; let ... - (,(lambda (end) (gf-match-let/in 'let end)) - 1 "(") - ;; ;; open ... - ;; (,(lambda (end) - ;; (and (re-search-forward "\\<ope\\(n\\)\\>" end t) - ;; (save-excursion - ;; (skip-syntax-forward " ") - ;; (not (eq ?\{ (char-after)))))) - ;; 1 "(") - ;; ... in - (,(lambda (end) (gf-match-let/in 'in end)) - 1 ")") - )) - - ;; (defvar gf-imenu-generic-expression - ;; ...) - - ;; (defvar gf-outline-regexp - ;; ...) - -;;;###autoload -(define-derived-mode gf-mode fundamental-mode "GF" - "A major mode for editing GF files." - ;; (set (make-local-variable 'imenu-generic-expression) - ;; gf-imenu-generic-expression) - ;; (set (make-local-variable 'outline-regexp) sample-outline-regexp) - (set (make-local-variable 'comment-start) "-- ") - (set (make-local-variable 'comment-start-skip) "[-{]-[ \t]*") - (set (make-local-variable 'font-lock-defaults) - '(gf-font-lock-keywords - nil nil nil nil - (font-lock-syntactic-keywords . gf-font-lock-syntactic-keywords) - )) - (set (make-local-variable 'indent-line-function) 'gf-indent-line) - (set (make-local-variable 'eldoc-documentation-function) 'gf-doc-display) - (set (make-local-variable 'beginning-of-defun-function) - 'gf-beginning-of-section) - (set (make-local-variable 'end-of-defun-function) - 'gf-end-of-section)) - -;;; Indentation -(defcustom gf-indent-basic-offset 2 - "*Number of columns to indent in GF mode." - :type 'integer - :group 'gf) - -(defcustom gf-indent-judgment-offset 2 - "*Column where judement should be indented to." - :type 'integer - :group 'gf) - -(defun gf-indent-line () - "Indent current line of GF code." - (interactive) - (save-excursion - (font-lock-fontify-syntactic-keywords-region - (point-at-bol) (point-at-bol))) - (let* ((case-fold-search nil) - (parse-sexp-lookup-properties t) - (parse-sexp-ignore-comments t) - (savep (> (current-column) (current-indentation))) - (indent (condition-case err - (max (gf-calculate-indentation) 0) - (error (message "%s" err) 0)))) - (if savep - (save-excursion (indent-line-to indent)) - (indent-line-to indent)))) - -(defun gf-beginning-of-section () - (when (re-search-backward - (concat "^\\s-*" gf-top-level-keyword-regexp) - nil 'move) - (goto-char (match-beginning 0))) - (point)) - -(defun gf-end-of-section () - (gf-forward-comment) - (when (looking-at gf-top-level-keyword-regexp) - (goto-char (match-end 0))) - (when (re-search-forward - (concat "^\\s-*" gf-top-level-keyword-regexp) - (condition-case nil - (1- (scan-lists (point) 1 1)) - (error nil)) - 'move) - (goto-char (match-beginning 0))) - (gf-backward-comment) - (point)) - -;; (defun gf-beginning-of-defun () -;; (let* ((beg (save-excursion (gf-beginning-of-section) (point))) -;; (end (save-excursion (progn (forward-line 0) (point)))) -;; (pps (parse-partial-sexp beg end))) -;; (when (nth 1 pps) (backward-up-list (nth 0 pps))) -;; (back-to-indentation) -;; (point))) - -(defun gf-beginning-of-sequence (&optional keep-going limit) - (or limit (let ((com-start (gf-in-comment-p))) - (when com-start - (save-excursion - (goto-char com-start) - (skip-chars-forward "{") - (skip-chars-forward "-") - (setq limit (point)))))) - (let* ((str "[;]") - (found-it nil) - (pps (gf-ppss)) - (depth (or (nth 0 pps) 0)) - (bol (point-at-bol)) - (lim (max (or limit (point-min)) - (if (nth 1 pps) - (1+ (nth 1 pps)) - (save-excursion - (gf-beginning-of-section) - (when (looking-at - (concat "\\s-*" gf-top-level-keyword-regexp)) - (goto-char (match-end 0)) - (gf-forward-comment)) - (point)))))) - (while (and (> (point) lim) - (setq found-it (re-search-backward str lim 'move)) - (let ((pps (gf-ppss))) - (or (/= depth (nth 0 pps)) - (nth 3 pps) - (nth 4 pps))))) - (when found-it - (when keep-going - (setq lim (max lim bol)) - (while (and (> (point) lim) - (setq found-it (re-search-backward str lim 'move)) - ;;(/= depth (nth 0 (gf-ppss))) - ))) - (when found-it (forward-char))))) - -(defun gf-in-comment-p () - (let ((pps (gf-ppss))) - (and (nth 4 pps) (nth 8 pps)))) - -(defun gf-forward-comment () (forward-comment (buffer-size))) -(defun gf-backward-comment () - (forward-comment (- (buffer-size))) - ;; (while (or (not (zerop (skip-chars-backward " \t\n"))) - ;; (let ((start (gf-in-comment))) - ;; (and start (goto-char start))))) - ) - - -(defun gf-ppss ();; (&optional from to) - (parse-partial-sexp - (save-excursion (gf-beginning-of-section)) - (point))) - -(if (fboundp 'syntax-after) - (defalias 'gf-syntax-after 'syntax-after) - (defun gf-syntax-after (pos) - "Return the raw syntax of the char after POS. -If POS is outside the buffer's accessible portion, return nil." - (unless (or (< pos (point-min)) (>= pos (point-max))) - (let ((st (if parse-sexp-lookup-properties - (get-char-property pos 'syntax-table)))) - (if (consp st) st - (aref (or st (syntax-table)) (char-after pos))))))) - -(if (fboundp 'syntax-class) - (defalias 'gf-syntax-class 'syntax-class) - (defun gf-syntax-class (syntax) - "Return the syntax class part of the syntax descriptor SYNTAX. -If SYNTAX is nil, return nil." - (and syntax (logand (car syntax) 65535)))) - -(defun gf-calculate-indentation () - "Return the column to which the current line should be indented." - (save-excursion - (forward-line 0) - (skip-chars-forward " \t") - (cond - ;; judgement - ((looking-at gf-top-level-keyword-regexp) - gf-indent-judgment-offset) - ((and gf-let-brace-style - (looking-at "in\\>")) - (if (condition-case nil - (progn (backward-up-list) - nil) - (error t)) - gf-indent-basic-offset - (gf-beginning-of-sequence) - (if (= (point) (point-min)) - 0 - (gf-forward-comment) - (+ gf-indent-basic-offset (current-column))))) - ((looking-at "[]})]") - ;; (looking-at "[]})]") - ;; (eq 5 (gf-syntax-class (gf-syntax-after (point)))) - (backward-up-list) - (gf-beginning-of-sequence) - (if (= (point) (point-min)) - 0 - (gf-forward-comment) - (+ gf-indent-basic-offset (current-column)))) - ;; heading - ((looking-at "---") - (gf-beginning-of-sequence) - (if (= (point) (point-min)) - 0 - gf-indent-judgment-offset)) - (t - (let ((opoint (point))) - (gf-backward-comment) - (cond - ((eq ?\; (char-before)) - ;; ?\, - (backward-char) - (gf-beginning-of-sequence t) - (gf-forward-comment) - (current-column)) - (;; (memq (char-before) '( ?\{ ?\[ ?\( ;; ?\< - ;; )) - (eq 4 (gf-syntax-class (gf-syntax-after (1- (point))))) - (backward-char) - ;; alt. (gf-beginning-of-sequence nil nil) - (gf-beginning-of-sequence nil (point-at-bol)) - (gf-forward-comment) - ;; alt. (+ (* 2 gf-indent-basic-offset) (current-column))) - (+ gf-indent-basic-offset (current-column))) - (t - (gf-beginning-of-sequence) - (let ((head (= (point) (point-min)))) - (gf-forward-comment) - (cond - ;; ((< opoint (point)) 0) - ((> opoint (point)) (+ gf-indent-basic-offset (current-column))) - ;; i.e. opoint == (point) - (head 0) - (t (gf-beginning-of-section) - (skip-chars-forward " \t") - (+ gf-indent-basic-offset (current-column)))))))))))) - -(defun gf-load-file () - (interactive) - (start-gf) - (comint-send-string gf-process (format "i %s\n" buffer-file-name)) - (gf-clear-lang-cache) - (gf-display-inf-buffer)) - -(defun gf-display-inf-buffer () - (interactive) - (and (get-buffer gf-process-buffer-name) - (display-buffer gf-process-buffer-name))) - -;; Inferior GF Mode ---------------- - -(defcustom gf-program-name "gf" - "*Name of GF shell invoked by `run-gf'." - :type 'file - :group 'gf) -(defvar gf-program-args nil "*Arguments passed to GF by `run-gf'.") -(defvar gf-process-buffer-name "*gf*") -(defvar gf-process) - -(require 'comint) - -(define-derived-mode inf-gf-mode comint-mode "Inf-GF" - (gf-setup-pcomplete)) - -(define-key inf-gf-mode-map "\t" 'gf-complete) - -;;;###autoload -(defun run-gf () - "Run an inferior GF process." - (interactive) - (start-gf) - (pop-to-buffer gf-process-buffer-name)) - -(defun start-gf () - (unless (comint-check-proc gf-process-buffer-name) - (with-current-buffer - (apply 'make-comint-in-buffer - "gf" gf-process-buffer-name gf-program-name - nil gf-program-args) - (setq gf-process (get-buffer-process (current-buffer))) - (set-buffer-process-coding-system 'latin-1-unix 'latin-1-unix) - (inf-gf-mode)))) - -;; (defun gf-norm-func (string) -;; (if (string-match "\\(.*\\)\\(=[^=]*\\)" string) -;; (match-string 1 string) -;; string)) - -;; (defmacro gf-pcomplete-here (&optional form stub paring form-only) -;; `(pcomplete-here ,form ,stub (or ,paring 'gf-norm-func) ,form-only)) -;; (put 'gf-pcomplete-here 'edebug-form-spec t) - -(put 'pcomplete-here 'edebug-form-spec t) - -(defun gf-setup-pcomplete () - (set (make-local-variable 'comint-prompt-regexp) "^[^>\n]*> *") - (set (make-local-variable 'pcomplete-ignore-case) nil) - (set (make-local-variable 'pcomplete-use-paring) t) - (set (make-local-variable 'pcomplete-suffix-list) '(?/ ?=)) - ;; (set (make-local-variable 'comint-dynamic-complete-functions) - ;; (add-to-list 'comint-dynamic-complete-functions 'pcomplete)) - (set (make-local-variable 'pcomplete-parse-arguments-function) - 'gf-parse-arguments) - (set (make-local-variable 'pcomplete-command-completion-function) - 'gf-complete-command) - ;; (set (make-local-variable 'pcomplete-command-name-function) - ;; 'pcomplete-erc-command-name) - (set (make-local-variable 'pcomplete-default-completion-function) - 'gf-default-completion-function) - (add-hook 'comint-input-filter-functions - 'gf-watch-for-loading - nil t)) - -(defun gf-watch-for-loading (string) - (when (string-match (concat "\\(\\`\\||\\;;\\)\\s-*" - (regexp-opt '("i" "e" "rl") 'words)) - string) - (gf-clear-lang-cache))) - -(defun gf-parse-arguments () - "Parse whitespace separated arguments in the current region." - (let ((begin (save-excursion - ;; (parse-partial-sexp begin end) - (if (re-search-backward "|\\|;;" (point-at-bol) t) - (match-end 0) - (comint-bol nil) - (point)))) - (end (point)) - begins args) - (save-excursion - (goto-char begin) - (while (< (point) end) - (skip-chars-forward " \t\n") - (setq begins (cons (point) begins)) - (let ((skip t)) - (while skip - (skip-chars-forward "^ \t\n") - (if (eq (char-before) ?\\) - (skip-chars-forward " \t\n") - (setq skip nil)))) - (setq args (cons (buffer-substring-no-properties - (car begins) (point)) - args))) - (cons (reverse args) (reverse begins))))) - -(defun gf-complete () - (interactive) - ;; (setq this-command 'pcomplete) - (pcomplete)) - -(defun gf-default-completion-function () - (pcomplete-here (pcomplete-entries))) - -(defun gf-complete-command () - (pcomplete-here (gf-complete-commands))) - -(defun gf-complete-commands () gf-short-command-names) - -;; (defun gf-complete-flagify (flags) -;; (mapcar (lambda (s) (concat s "=")) flags)) - -(defvar gf-short-command-names - '("i" "rl" "e" "sf" "s" "pg" "pm" "vg" "po" "pl" "pi" - "eh" "ph" "l" "p" "tt" "cc" "so" "t" "gr" "gt" "ma" - "ps" "pt" "st" "wt" "vt" "es" "ts" "tq" "tl" "mq" - "ml" "rf" "wf" "af" "tg" "cl" "sa" "h" "q" "!")) - -(defvar gf-long-command-names - '("import" "remove_language" "empty" "set_flags" "strip" - "print_grammar" "print_multigrammar" "visualize_graph" - "print_options" "print_languages" "print_info" - "execute_history" "print_history" "linearize" "parse" "test_tokenizer" - "compute_concrete" "show_operations" "translate" "generate_random" - "generate_trees" "morphologically_analyse" "put_string" "put_tree" - "show_tree" "wrap_tree" "visualize_tree" "editing_session" - "translation_session" "translation_quiz" "translation_list" - "morphology_quiz" "morphology_list" "read_file" "write_file" - "append_file" "transform_grammar" "convert_latex" "speak_aloud" - "help" "quit" "system_command")) - -(defun gf-complete-options (options flags &optional flags-extra-table - extra-completions) - (let ((-options (mapcar (lambda (s) (concat "-" s)) options)) - (-flags= (mapcar (lambda (s) (concat "-" s "=")) flags))) - ;; do-while - (while (progn - (cond - ((pcomplete-match "\\`-\\(\\w+\\)=\\(.*\\)" 0) - (pcomplete-here - (let ((opt (cdr (assoc (car (member - (pcomplete-match-string 1 0) - flags)) - (append flags-extra-table - gf-flags-table))))) - (if (functionp opt) - (funcall opt) - opt)) - (pcomplete-match-string 2 0))) - (t (pcomplete-here - (append - (if (functionp extra-completions) - (funcall extra-completions) - extra-completions) - -options -flags=)))) - (pcomplete-match "\\`-" 1))))) - -(defun gf-collect-results (process command function) - (let ((output-buffer " *gf-tmp*") - results) - (save-excursion - (set-buffer (get-buffer-create output-buffer)) - (erase-buffer) - (comint-redirect-send-command-to-process - command output-buffer process nil t) - ;; Wait for the process to complete - (set-buffer (process-buffer process)) - (while (null comint-redirect-completed) - (accept-process-output nil 1)) - ;; Collect the output - (set-buffer output-buffer) - (goto-char (point-min)) - ;; Skip past the command, if it was echoed - (and (looking-at command) (forward-line)) - (funcall function)))) - -;; Command Completion --------------------------------------------- - -;; i, import: i File -;; Reads a grammar from File and compiles it into a GF runtime grammar. -;; Files "include"d in File are read recursively, nubbing repetitions. -;; If a grammar with the same language name is already in the state, -;; it is overwritten - but only if compilation succeeds. -;; The grammar parser depends on the file name suffix: -;; .gf normal GF source -;; .gfc canonical GF -;; .gfr precompiled GF resource -;; .gfcm multilingual canonical GF -;; .gfe example-based grammar files (only with the -ex option) -;; .ebnf Extended BNF format -;; .cf Context-free (BNF) format -;; options: -;; -old old: parse in GF<2.0 format (not necessary) -;; -v verbose: give lots of messages -;; -s silent: don't give error messages -;; -src source: ignore precompiled gfc and gfr files -;; -retain retain operations: read resource modules (needed in comm cc) -;; -nocf don't build context-free grammar (thus no parser) -;; -nocheckcirc don't eliminate circular rules from CF -;; -cflexer build an optimized parser with separate lexer trie -;; -noemit do not emit code (default with old grammar format) -;; -o do emit code (default with new grammar format) -;; -ex preprocess .gfe files if needed -;; flags: -;; -abs set the name used for abstract syntax (with -old option) -;; -cnc set the name used for concrete syntax (with -old option) -;; -res set the name used for resource (with -old option) -;; -path use the (colon-separated) search path to find modules -;; -optimize select an optimization to override file-defined flags -;; -conversion select parsing method (values strict|nondet) -;; examples: -;; i English.gf -- ordinary import of Concrete -;; i -retain german/ParadigmsGer.gf -- import of Resource to test - -(defun pcomplete/inf-gf-mode/i () - (gf-complete-options - '("old" "v" "s" "src" "retain" "nocf" "nocheckcirc" - "cflexer" "noemit" "o" "ex") - '("abs" "cnc" "res" "path" "optimize" "conversion") - '(("conversion" . ("strict" "nondet"))) - (lambda () - (pcomplete-dirs-or-entries - (regexp-opt - '(".gf" ".gfc" ".gfr" ".gfcm" ".gfe" ".ebnf" ".cf" - ".trc")))))) - -;; * rl, remove_language: rl Language -;; Takes away the language from the state. -(defun pcomplete/inf-gf-mode/rl () - (pcomplete-here (gf-complete-lang))) - -;; e, empty: e -;; Takes away all languages and resets all global flags. -(defun pcomplete/inf-gf-mode/e ()) - -;; sf, set_flags: sf Flag* -;; The values of the Flags are set for Language. If no language -;; is specified, the flags are set globally. -;; examples: -;; sf -nocpu -- stop showing CPU time -;; sf -lang=Swe -- make Swe the default concrete -(defun pcomplete/inf-gf-mode/sf () - (message "Usage: sf Flag*") - (throw 'pcompleted nil)) - -;; s, strip: s -;; Prune the state by removing source and resource modules. -(defun pcomplete/inf-gf-mode/s ()) - -;; pg, print_grammar: pg -;; Prints the actual grammar (overridden by the -lang=X flag). -;; The -printer=X flag sets the format in which the grammar is -;; written. -;; N.B. since grammars are compiled when imported, this command -;; generally does not show the grammar in the same format as the -;; source. In particular, the -printer=latex is not supported. -;; Use the command tg -printer=latex File to print the source -;; grammar in LaTeX. -;; options: -;; -utf8 apply UTF8-encoding to the grammar -;; flags: -;; -printer -;; -lang -;; examples: -;; pg -printer=cf -- show the context-free skeleton -(defun pcomplete/inf-gf-mode/pg () - (gf-complete-options '("utf8") - '("printer" "lang"))) - ;; (while (progn - ;; (cond - ;; ((pcomplete-match "\\`-printer=\\(.*\\)" 0) - ;; (pcomplete-here gf-flag-printer-options - ;; (pcomplete-match-string 1 0))) - ;; ((pcomplete-match "\\`-\\w+=" 0) - ;; (pcomplete-here)) - ;; (t (pcomplete-here - ;; (append '("-utf8") - ;; '("-printer=" "-lang="))))) - ;; (pcomplete-match "\\`-" 1))) - -;; pm, print_multigrammar: pm -;; Prints the current multilingual grammar in .gfcm form. -;; (Automatically executes the strip command (s) before doing this.) -;; options: -;; -utf8 apply UTF8 encoding to the tokens in the grammar -;; -utf8id apply UTF8 encoding to the identifiers in the grammar -;; -graph print module dependency graph in 'dot' format -;; examples: -;; pm | wf Letter.gfcm -- print the grammar into the file Letter.gfcm -;; pm -printer=graph | wf D.dot -- then do 'dot -Tps D.dot > D.ps' -(defun pcomplete/inf-gf-mode/pm () - (gf-complete-options '("utf8" "utf8id" "graph") - '("printer" "lang") - '(("printer" . ("graph"))))) - -;; vg, visualize_graph: vg -;; Show the dependency graph of multilingual grammar via dot and gv. -(defun pcomplete/inf-gf-mode/vg ()) - -;; po, print_options: po -;; Print what modules there are in the state. Also prints those -;; flag values in the current state that differ from defaults. -(defun pcomplete/inf-gf-mode/po ()) - -;; pl, print_languages: pl -;; Prints the names of currently available languages. -(defun pcomplete/inf-gf-mode/pl ()) - -;; pi, print_info: pi Ident -;; Prints information on the identifier. -(defun pcomplete/inf-gf-mode/pi () - (message "Usage: pi Ident") - (throw 'pcompleted nil)) - -;; eh, execute_history: eh File -;; Executes commands in the file. -(defun pcomplete/inf-gf-mode/eh () - (pcomplete-here (pcomplete-entries))) - -;; ph, print_history; ph -;; Prints the commands issued during the GF session. -;; The result is readable by the eh command. -;; examples: -;; ph | wf foo.hist" -- save the history into a file -(defun pcomplete/inf-gf-mode/ph ()) - -;; -- linearization, parsing, translation, and computation - -;; l, linearize: l PattList? Tree -;; Shows all linearization forms of Tree by the actual grammar -;; (which is overridden by the -lang flag). -;; The pattern list has the form [P, ... ,Q] where P,...,Q follow GF -;; syntax for patterns. All those forms are generated that match with the -;; pattern list. Too short lists are filled with variables in the end. -;; Only the -table flag is available if a pattern list is specified. -;; HINT: see GF language specification for the syntax of Pattern and Term. -;; You can also copy and past parsing results. -;; options: -;; -table show parameters -;; -struct bracketed form -;; -record record, i.e. explicit GF concrete syntax term -;; -all show all forms and variants -;; -multi linearize to all languages (the other options don't work) -;; flags: -;; -lang linearize in this grammar -;; -number give this number of forms at most -;; -unlexer filter output through unlexer -;; examples: -;; l -lang=Swe -table -- show full inflection table in Swe -(defun pcomplete/inf-gf-mode/l () - (gf-complete-options '("table" "struct" "record" "all" "multi") - '("lang" "number" "unlexer")) - (message "Usage: l [-option*] PattList? Tree") - (throw 'pcompleted nil)) - -;; p, parse: p String -;; Shows all Trees returned for String by the actual -;; grammar (overridden by the -lang flag), in the category S (overridden -;; by the -cat flag). -;; options for batch input: -;; -lines parse each line of input separately, ignoring empty lines -;; -all as -lines, but also parse empty lines -;; options for selecting parsing method: -;; (default)parse using an overgenerating CFG -;; -cfg parse using a much less overgenerating CFG -;; -mcfg parse using an even less overgenerating MCFG -;; Note: the first time parsing with -cfg or -mcfg might take a long time -;; options that only work for the default parsing method: -;; -n non-strict: tolerates morphological errors -;; -ign ignore unknown words when parsing -;; -raw return context-free terms in raw form -;; -v verbose: give more information if parsing fails -;; flags: -;; -cat parse in this category -;; -lang parse in this grammar -;; -lexer filter input through this lexer -;; -parser use this parsing strategy -;; -number return this many results at most -;; examples: -;; p -cat=S -mcfg "jag är gammal" -- parse an S with the MCFG -;; rf examples.txt | p -lines -- parse each non-empty line of the file -(defun pcomplete/inf-gf-mode/p () - (gf-complete-options - '("lines" "all" "cfg" "mcfg" "n" "ign" "raw" "v") - '("cat" "lang" "lexer" "parser" "number")) - (message "Usage: p [-option*] String") - (throw 'pcompleted nil)) - -;; tt, test_tokenizer: tt String -;; Show the token list sent to the parser when String is parsed. -;; HINT: can be useful when debugging the parser. -;; flags: -;; -lexer use this lexer -;; examples: -;; tt -lexer=codelit "2*(x + 3)" -- a favourite lexer for program code -(defun pcomplete/inf-gf-mode/tt () - (gf-complete-options '() '("lexer")) - (message "Usage: tt [-lexer] String") - (throw 'pcompleted nil)) - -;; cc, compute_concrete: cc Term -;; Compute a term by concrete syntax definitions. Uses the topmost -;; resource module (the last in listing by command po) to resolve -;; constant names. -;; N.B. You need the flag -retain when importing the grammar, if you want -;; the oper definitions to be retained after compilation; otherwise this -;; command does not expand oper constants. -;; N.B.' The resulting Term is not a term in the sense of abstract syntax, -;; and hence not a valid input to a Tree-demanding command. -;; flags: -;; -res use another module than the topmost one -;; examples: -;; cc -res=ParadigmsFin (nLukko "hyppy") -- inflect "hyppy" with nLukko -(defun pcomplete/inf-gf-mode/cc () - (gf-complete-options '() '("res")) - (message "Usage: cc [-res] Term") - (throw 'pcompleted nil)) - -;; so, show_operations: so Type -;; Show oper operations with the given value type. Uses the topmost -;; resource module to resolve constant names. -;; N.B. You need the flag -retain when importing the grammar, if you want -;; the oper definitions to be retained after compilation; otherwise this -;; command does not find any oper constants. -;; N.B.' The value type may not be defined in a supermodule of the -;; topmost resource. In that case, use appropriate qualified name. -;; flags: -;; -res use another module than the topmost one -;; examples: -;; so -res=ParadigmsFin ResourceFin.N -- show N-paradigms in ParadigmsFin -(defun pcomplete/inf-gf-mode/so () - (gf-complete-options '() '("res")) - (message "Usage: so [-res] Type") - (throw 'pcompleted nil)) - -;; t, translate: t Lang Lang String -;; Parses String in Lang1 and linearizes the resulting Trees in Lang2. -;; flags: -;; -cat -;; -lexer -;; -parser -;; examples: -;; t Eng Swe -cat=S "every number is even or odd" -(defun pcomplete/inf-gf-mode/t () - (gf-complete-options '() '("cat" "lexer" "parser")) - (message "Usage: t [-options] Lang Lang String") - (throw 'pcompleted nil)) - -;; gr, generate_random: gr Tree? -;; Generates a random Tree of a given category. If a Tree -;; argument is given, the command completes the Tree with values to -;; the metavariables in the tree. -;; flags: -;; -cat generate in this category -;; -lang use the abstract syntax of this grammar -;; -number generate this number of trees (not impl. with Tree argument) -;; -depth use this number of search steps at most -;; examples: -;; gr -cat=Query -- generate in category Query -;; gr (PredVP ? (NegVG ?)) -- generate a random tree of this form -;; gr -cat=S -tr | l -- gererate and linearize -(defun pcomplete/inf-gf-mode/gr () - (ding) - (gf-complete-options '() '("cat" "lang" "number" "depth")) - (message "Usage: gr [-options] Tree?") - (throw 'pcompleted nil)) - -;; gt, generate_trees: gt Tree? -;; Generates all trees up to a given depth. If the depth is large, -;; a small -alts is recommended. If a Tree argument is given, the -;; command completes the Tree with values to the metavariables in -;; the tree. -;; options: -;; -metas also return trees that include metavariables -;; flags: -;; -depth generate to this depth (default 3) -;; -alts take this number of alternatives at each branch (default unlimited) -;; -cat generate in this category -;; -lang use the abstract syntax of this grammar -;; -number generate (at most) this number of trees -;; examples: -;; gt -depth=10 -cat=NP -- generate all NP's to depth 10 -;; gt (PredVP ? (NegVG ?)) -- generate all trees of this form -;; gt -cat=S -tr | l -- gererate and linearize -(defun pcomplete/inf-gf-mode/gt () - (gf-complete-options '("metas") - '("depth" "alts" "cat" "lang" "number"))) - -;; ma, morphologically_analyse: ma String -;; Runs morphological analysis on each word in String and displays -;; the results line by line. -;; options: -;; -short show analyses in bracketed words, instead of separate lines -;; flags: -;; -lang -;; examples: -;; wf Bible.txt | ma -short | wf Bible.tagged -- analyse the Bible -(defun pcomplete/inf-gf-mode/ma () - (gf-complete-options '("short") '("lang"))) - -;; -- elementary generation of Strings and Trees - -;; ps, put_string: ps String -;; Returns its argument String, like Unix echo. -;; HINT. The strength of ps comes from the possibility to receive the -;; argument from a pipeline, and altering it by the -filter flag. -;; flags: -;; -filter filter the result through this string processor -;; -length cut the string after this number of characters -;; examples: -;; gr -cat=Letter | l | ps -filter=text -- random letter as text -(defun pcomplete/inf-gf-mode/ps () - (gf-complete-options '() '("filter" "length"))) - -;; pt, put_tree: pt Tree -;; Returns its argument Tree, like a specialized Unix echo. -;; HINT. The strength of pt comes from the possibility to receive -;; the argument from a pipeline, and altering it by the -transform flag. -;; flags: -;; -transform transform the result by this term processor -;; -number generate this number of terms at most -;; examples: -;; p "zero is even" | pt -transform=solve -- solve ?'s in parse result -(defun pcomplete/inf-gf-mode/pt () - (gf-complete-options '() '("transform" "number"))) - -;; * st, show_tree: st Tree -;; Prints the tree as a string. Unlike pt, this command cannot be -;; used in a pipe to produce a tree, since its output is a string. -;; flags: -;; -printer show the tree in a special format (-printer=xml supported) -(defun pcomplete/inf-gf-mode/st ()) - -;; wt, wrap_tree: wt Fun -;; Wraps the tree as the sole argument of Fun. -;; flags: -;; -c compute the resulting new tree to normal form -(defun pcomplete/inf-gf-mode/wt () - (gf-complete-options '("c") '())) - -;; vt, visualize_tree: vt Tree -;; Shows the abstract syntax tree via dot and gv (via temporary files -;; grphtmp.dot, grphtmp.ps). -;; flags: -;; -c show categories only (no functions) -;; -f show functions only (no categories) -;; -g show as graph (sharing uses of the same function) -;; -o just generate the .dot file -;; examples: -;; p "hello world" | vt -o | wf my.dot ;; ! open -a GraphViz my.dot -;; -- This writes the parse tree into my.dot and opens the .dot file -;; -- with another application without generating .ps. -(defun pcomplete/inf-gf-mode/vt () - (gf-complete-options '("c" "f" "g" "o") '())) - -;; -- subshells - -;; es, editing_session: es -;; Opens an interactive editing session. -;; N.B. Exit from a Fudget session is to the Unix shell, not to GF. -;; options: -;; -f Fudget GUI (necessary for Unicode; only available in X Window System) - -;; ts, translation_session: ts -;; Translates input lines from any of the actual languages to all other ones. -;; To exit, type a full stop (.) alone on a line. -;; N.B. Exit from a Fudget session is to the Unix shell, not to GF. -;; HINT: Set -parser and -lexer locally in each grammar. -;; options: -;; -f Fudget GUI (necessary for Unicode; only available in X Windows) -;; -lang prepend translation results with language names -;; flags: -;; -cat the parser category -;; examples: -;; ts -cat=Numeral -lang -- translate numerals, show language names -(defun pcomplete/inf-gf-mode/ts () - (gf-complete-options '("f" "lang") '("cat"))) - -;; tq, translation_quiz: tq Lang Lang -;; Random-generates translation exercises from Lang1 to Lang2, -;; keeping score of success. -;; To interrupt, type a full stop (.) alone on a line. -;; HINT: Set -parser and -lexer locally in each grammar. -;; flags: -;; -cat -;; examples: -;; tq -cat=NP TestResourceEng TestResourceSwe -- quiz for NPs -(defun pcomplete/inf-gf-mode/tq () - (pcomplete-here (gf-complete-lang)) - (pcomplete-here (gf-complete-lang))) - -;; tl, translation_list: tl Lang Lang -;; Random-generates a list of ten translation exercises from Lang1 -;; to Lang2. The number can be changed by a flag. -;; HINT: use wf to save the exercises in a file. -;; flags: -;; -cat -;; -number -;; examples: -;; tl -cat=NP TestResourceEng TestResourceSwe -- quiz list for NPs -(defun pcomplete/inf-gf-mode/tl () - (pcomplete-here (gf-complete-lang)) - (pcomplete-here (gf-complete-lang))) - -;; mq, morphology_quiz: mq -;; Random-generates morphological exercises, -;; keeping score of success. -;; To interrupt, type a full stop (.) alone on a line. -;; HINT: use printname judgements in your grammar to -;; produce nice expressions for desired forms. -;; flags: -;; -cat -;; -lang -;; examples: -;; mq -cat=N -lang=TestResourceSwe -- quiz for Swedish nouns - -;; ml, morphology_list: ml -;; Random-generates a list of ten morphological exercises, -;; keeping score of success. The number can be changed with a flag. -;; HINT: use wf to save the exercises in a file. -;; flags: -;; -cat -;; -lang -;; -number -;; examples: -;; ml -cat=N -lang=TestResourceSwe -- quiz list for Swedish nouns -(defun pcomplete/inf-gf-mode/ml () - (gf-complete-options '() '("cat" "lang" "number"))) - -;; -- IO related commands - -;; rf, read_file: rf File -;; Returns the contents of File as a String; error if File does not exist. -(defun pcomplete/inf-gf-mode/rf () - (pcomplete-here (pcomplete-entries))) - -;; wf, write_file: wf File String -;; Writes String into File; File is created if it does not exist. -;; N.B. the command overwrites File without a warning. - -;; af, append_file: af File -;; Writes String into the end of File; File is created if it does not exist. - -;; * tg, transform_grammar: tg File -;; Reads File, parses as a grammar, -;; but instead of compiling further, prints it. -;; The environment is not changed. When parsing the grammar, the same file -;; name suffixes are supported as in the i command. -;; HINT: use this command to print the grammar in -;; another format (the -printer flag); pipe it to wf to save this format. -;; flags: -;; -printer (only -printer=latex supported currently) - -;; * cl, convert_latex: cl File -;; Reads File, which is expected to be in LaTeX form. -;; Three environments are treated in special ways: -;; \begGF - \end{verbatim}, which contains GF judgements, -;; \begTGF - \end{verbatim}, which contains a GF expression (displayed) -;; \begInTGF - \end{verbatim}, which contains a GF expressions (inlined). -;; Moreover, certain macros should be included in the file; you can -;; get those macros by applying 'tg -printer=latex foo.gf' to any grammar -;; foo.gf. Notice that the same File can be imported as a GF grammar, -;; consisting of all the judgements in \begGF environments. -;; HINT: pipe with 'wf Foo.tex' to generate a new Latex file. - -;; sa, speak_aloud: sa String -;; Uses the Flite speech generator to produce speech for String. -;; Works for American English spelling. -;; examples: -;; h | sa -- listen to the list of commands -;; gr -cat=S | l | sa -- generate a random sentence and speak it aloud - -;; h, help: h Command? -;; Displays the paragraph concerning the command from this help file. -;; Without the argument, shows the first lines of all paragraphs. -;; options -;; -all show the whole help file -;; examples: -;; h print_grammar -- show all information on the pg command - -;; q, quit: q -;; Exits GF. -;; HINT: you can use 'ph | wf history' to save your session. - -;; !, system_command: ! String -;; Issues a system command. No value is returned to GF. -;; example: -;; ! ls -(defun pcomplete/inf-gf-mode/! () - ;;(pcomplete-here (eshell-complete-commands-list)) - ) - -;; -- Flags. The availability of flags is defined separately for each command. - -;; -cat, category in which parsing is performed. -;; The default is S. - -;; -depth, the search depth in e.g. random generation. -;; The default depends on application. - -;; -filter, operation performed on a string. The default is identity. -;; -filter=identity no change -;; -filter=erase erase the text -;; -filter=take100 show the first 100 characters -;; -filter=length show the length of the string -;; -filter=text format as text (punctuation, capitalization) -;; -filter=code format as code (spacing, indentation) -(defvar gf-flag-filter-options - '("identity" "erase" "take100" "length" "text" "code")) - -;; -lang, grammar used when executing a grammar-dependent command. -;; The default is the last-imported grammar. - -(defvar gf-lang-cache 'empty) -(defun gf-clear-lang-cache () (setq gf-lang-cache 'empty)) - -(defvar gf-flag-lang-options 'gf-complete-lang) -(defun gf-complete-lang () - (if (listp gf-lang-cache) - gf-lang-cache - (setq gf-lang-cache - (gf-collect-results - gf-process "pl" - (lambda () - ;; we're at point-min - (let (result) - (while (re-search-forward "\\S-+" (point-at-eol) t) - (push (match-string 0) result)) - result)))))) - -;; -language, voice used by Festival as its --language flag in the sa command. -;; The default is system-dependent. - -;; -length, the maximum number of characters shown of a string. -;; The default is unlimited. - -;; -lexer, tokenization transforming a string into lexical units for a parser. -;; The default is words. -;; -lexer=words tokens are separated by spaces or newlines -;; -lexer=literals like words, but GF integer and string literals recognized -;; -lexer=vars like words, but "x","x_...","$...$" as vars, "?..." as meta -;; -lexer=chars each character is a token -;; -lexer=code use Haskell's lex -;; -lexer=codevars like code, but treat unknown words as variables, ?? as meta -;; -lexer=text with conventions on punctuation and capital letters -;; -lexer=codelit like code, but treat unknown words as string literals -;; -lexer=textlit like text, but treat unknown words as string literals -;; -lexer=codeC use a C-like lexer -(defvar gf-flag-lexer-options - '("words" "literals" "vars" "chars" "code" "codevars" - "text" "codelit" "textlit" "codeC")) - -;; -number, the maximum number of generated items in a list. -;; The default is unlimited. - -;; -optimize, optimization on generated code. -;; The default is share for concrete, none for resource modules. -;; Each of the flags can have the suffix _subs, which performs -;; common subexpression elimination after the main optimization. -;; Thus, -optimize=all_subs is the most aggressive one. - -;; -optimize=share share common branches in tables -;; -optimize=parametrize first try parametrize then do share with the rest -;; -optimize=values represent tables as courses-of-values -;; -optimize=all first try parametrize then do values with the rest -;; -optimize=none no optimization -(defvar gf-flag-optimize-options - '("share" "parametrize" "values" "all" "none")) - -;; -parser, parsing strategy. The default is chart. If -cfg or -mcfg are selected, only bottomup and topdown are recognized. -;; -parser=chart bottom-up chart parsing -;; -parser=bottomup a more up to date bottom-up strategy -;; -parser=topdown top-down strategy -;; -parser=old an old bottom-up chart parser -(defvar gf-flag-parser-options - '("chart" "bottomup" "topdown" "old")) - -;; -printer, format in which the grammar is printed. The default is gfc. -;; -printer=gfc GFC grammar -;; -printer=gf GF grammar -;; -printer=old old GF grammar -;; -printer=cf context-free grammar, with profiles -;; -printer=bnf context-free grammar, without profiles -;; -printer=lbnf labelled context-free grammar for BNF Converter -;; -printer=plbnf grammar for BNF Converter, with precedence levels -;; *-printer=happy source file for Happy parser generator (use lbnf!);; -printer=srg speech recognition grammar -;; -printer=haskell abstract syntax in Haskell, with transl to/from GF -;; -printer=morpho full-form lexicon, long format -;; *-printer=latex LaTeX file (for the tg command) -;; -printer=fullform full-form lexicon, short format -;; *-printer=xml XML: DTD for the pg command, object for st -;; -printer=old old GF: file readable by GF 1.2 -;; -printer=stat show some statistics of generated GFC -;; -printer=gsl Nuance GSL speech recognition grammar -;; -printer=jsgf Java Speech Grammar Format -;; -printer=slf a finite automaton in the HTK SLF format -;; -printer=slf_graphviz the same automaton as in SLF, but in Graphviz format -;; -printer=fa_graphviz a finite automaton with labelled edges -;; -printer=regular a regular grammar in a simple BNF -;; -printer=unpar a gfc grammar with parameters eliminated -(defvar gf-flag-printer-options - '("gfc" "gf" "cf" "old" "srg" "gsl" "jsgf" "slf" "slf_graphviz" - "fa_graphviz" "regular" "plbnf" "lbnf" "bnf" "haskell" "morpho" - "fullform" "opts" "words" "printnames" "stat" "unpar" "subs" - "mcfg" "cfg" "pinfo" "abstract" "gfc-haskell" "mcfg-haskell" - "cfg-haskell" "gfc-prolog" "mcfg-prolog" "cfg-prolog" "abs-skvatt" - "cfg-skvatt" "simple" "mcfg-erasing" "mcfg-old" "cfg-old" - ;;"happy" "latex" "xml" - )) - - -;; -startcat, like -cat, but used in grammars (to avoid clash with keyword cat) - -;; -transform, transformation performed on a syntax tree. The default is identity. -;; -transform=identity no change -;; -transform=compute compute by using definitions in the grammar -;; -transform=typecheck return the term only if it is type-correct -;; -transform=solve solve metavariables as derived refinements -;; -transform=context solve metavariables by unique refinements as variables -;; -transform=delete replace the term by metavariable -(defvar gf-flag-transform-options - '("identity" "compute" "typecheck" "solve" "context" "delete")) - -;; -unlexer, untokenization transforming linearization output into a string. -;; The default is unwords. -;; -unlexer=unwords space-separated token list (like unwords) -;; -unlexer=text format as text: punctuation, capitals, paragraph <p> -;; -unlexer=code format as code (spacing, indentation) -;; -unlexer=textlit like text, but remove string literal quotes -;; -unlexer=codelit like code, but remove string literal quotes -;; -unlexer=concat remove all spaces -;; -unlexer=bind like identity, but bind at "&+" -(defvar gf-flag-unlexer-options - '("unwords" "text" "code" "textlit" "codelit" "concat" "bind")) - -;; -- *: Commands and options marked with * are not yet implemented. - -(defvar gf-flags-table - `(("filter" . ,gf-flag-filter-options) - ("lang" . ,gf-flag-lang-options) - ("lexer" . ,gf-flag-lexer-options) - ("optimize" . ,gf-flag-optimize-options) - ("parser" . ,gf-flag-parser-options) - ("printer" . ,gf-flag-printer-options) - ("transform" . ,gf-flag-transform-options) - ("unlexer" . ,gf-flag-unlexer-options))) - -;;; gf.el ends here +(error "install updated GF mode from https://github.com/GrammaticalFramework/gf-emacs-mode") |