~ubuntu-branches/ubuntu/vivid/inform/vivid

;;; inform-mode.el --- Inform mode for Emacs

;; Original-Author: Gareth Rees <Gareth.Rees@cl.cam.ac.uk>

;; Maintainer: Rupert Lane <rupert@rupert-lane.org>

;; Created: 1 Dec 1994

;; Version: 1.5.8

;; Released: 3 Sep 2002

;; Keywords: languages

;;; Copyright:

;; Copyright (c) by Gareth Rees 1996

;; Portions copyright (c) by Michael Fessler 1997-1998

;; Portions copyright (c) by Rupert Lane 1999-2000, 2002

;; inform-mode 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.

;;

;; inform-mode 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.

;;; Commentary:

;; Inform is a compiler for adventure games by Graham Nelson,

;; available by anonymous FTP from

;; /ftp.ifarchive.org:/if-archive/programming/inform/

;;

;; This file implements a major mode for editing Inform programs.  It

;; understands most Inform syntax and is capable of indenting lines

;; and formatting quoted strings.  Type `C-h m' within Inform mode for

;; more details.

;;

;; Because Inform header files use the extension ".h" just as C header

;; files do, the function `inform-maybe-mode' is provided.  It looks at

;; the contents of the current buffer; if it thinks the buffer is in

;; Inform, it selects inform-mode; otherwise it selects the mode given

;; by the variable `inform-maybe-other'.

;; Put this file somewhere on your load-path, and the following code in

;; your .emacs file:

;;

;;  (autoload 'inform-mode "inform-mode" "Inform editing mode." t)

;;  (autoload 'inform-maybe-mode "inform-mode" "Inform/C header editing mode.")

;;  (setq auto-mode-alist

;;        (append '(("\\.h\\'"   . inform-maybe-mode)

;;                  ("\\.inf\\'" . inform-mode))

;;                auto-mode-alist))

;;

;; To turn on font locking add:

;; (add-hook 'inform-mode-hook 'turn-on-font-lock)

;; If you use XEmacs and intend to use `inform-run-project' with a

;; console-mode interpreter, you need to have the eterm package

;; installed.  It should already be installed if you use XEmacs < 21,

;; but starting with XEmacs 21.1 you may need to download and install

;; it separately.

;; Please send any bugs or comments to rupert@rupert-lane.org

;;; Code:

(require 'font-lock)

(require 'regexp-opt)

;;;

;;; General variables

;;;

(defconst inform-mode-version "1.5.8")

(defvar inform-maybe-other 'c-mode

  "*`inform-maybe-mode' runs this if current file is not in Inform mode.")

(defvar inform-startup-message t

  "*Non-nil means display a message when Inform mode is loaded.")

(defvar inform-auto-newline t

  "*Non-nil means automatically newline before and after braces, and after 

semicolons.

If you do not want a leading newline before opening braces then use:

  \(define-key inform-mode-map \"{\" 'inform-electric-semi\)")

(defvar inform-mode-map nil

  "Keymap for Inform mode.")

(if inform-mode-map nil

  (let ((map (make-sparse-keymap "Inform")))

    (setq inform-mode-map (make-sparse-keymap))

    (define-key inform-mode-map "\C-m" 'newline-and-indent)

    (define-key inform-mode-map "\177" 'backward-delete-char-untabify)

    (define-key inform-mode-map "\C-c\C-r" 'inform-retagify)

    (define-key inform-mode-map "\C-c\C-t" 'visit-tags-table)

    (define-key inform-mode-map "\C-c\C-b" 'inform-build-project)

    (define-key inform-mode-map "\C-c\C-c" 'inform-run-project)

    (define-key inform-mode-map "\C-c\C-a" 'inform-toggle-auto-newline)

    (define-key inform-mode-map "\C-c\C-s" 'inform-spell-check-buffer)

    (define-key inform-mode-map "\M-n" 'inform-next-object)

    (define-key inform-mode-map "\M-p" 'inform-prev-object)

    (define-key inform-mode-map "{" 'inform-electric-brace)

    (define-key inform-mode-map "}" 'inform-electric-brace)

    (define-key inform-mode-map "]" 'inform-electric-brace)

    (define-key inform-mode-map ";" 'inform-electric-semi)

    (define-key inform-mode-map ":" 'inform-electric-key)

    (define-key inform-mode-map "!" 'inform-electric-key)

    (define-key inform-mode-map "," 'inform-electric-comma)

    (define-key inform-mode-map [menu-bar] (make-sparse-keymap))

    (define-key inform-mode-map [menu-bar inform] (cons "Inform" map))

    (define-key map [separator4] '("--" . nil))

    (define-key map [inform-spell-check-buffer] 

      '("Spellcheck buffer" . inform-spell-check-buffer))

    (define-key map [ispell-region] '("Spellcheck region" . ispell-region))

    (define-key map [ispell-word] '("Spellcheck word" . ispell-word))

    (define-key map [separator3] '("--" . nil))

    (define-key map [load-tags] '("Load tags table" . visit-tags-table))

    (define-key map [retagify] '("Rebuild tags table" . inform-retagify))

    (define-key map [build] '("Build project" . inform-build-project))

    (define-key map [run] '("Run project" . inform-run-project))

    (define-key map [separator2] '("--" . nil))

    (define-key map [next-object] '("Next object" . inform-next-object))

    (define-key map [prev-object] '("Previous object" . inform-prev-object))

    (define-key map [separator1] '("--" . nil))

    (define-key map [comment-region] '("Comment Out Region" . comment-region))

    (put 'comment-region 'menu-enable 'mark-active)

    (define-key map [indent-region] '("Indent Region" . indent-region))

    (put 'indent-region 'menu-enable 'mark-active)

    (define-key map [indent-line] '("Indent Line" . indent-for-tab-command))))

(defvar inform-mode-abbrev-table nil

  "Abbrev table used while in Inform mode.")

(define-abbrev-table 'inform-mode-abbrev-table nil)

(defvar inform-project-file nil

  "*The top-level Inform project file to which the current file belongs.")

(make-variable-buffer-local 'inform-project-file)

(defvar inform-autoload-tags t

  "*Non-nil means automatically load tags table when entering Inform mode.")

(defvar inform-etags-program "etags"

  "The shell command with which to run the etags program.")

(defvar inform-command "inform"

  "*The shell command with which to run the Inform compiler.")

(defvar inform-libraries-directory nil

  "*If non-NIL, gives the directory in which libraries are found.")

(defvar inform-command-options ""

  "*Options with which to call the Inform compiler.")

(defvar inform-interpreter-command "frotz"

  "*The command with which to run the ZCode interpreter.

If a string, the name of a command.  If a symbol or a function value, an

Emacs-lisp function to be called with the name of the story file.")

(defvar inform-interpreter-options ""

  "*Additional options with which to call the ZCode interpreter.

Only used if `inform-interpreter-command' is a string.")

(defvar inform-interpreter-kill-old-process t

  "*Whether to kill the old interpreter process when starting a new one.")

(defvar inform-interpreter-is-graphical nil

  "*Controls whether `inform-interpreter-command' will be run in a buffer.

If NIL, `inform-run-project' will switch to the interpreter buffer after

running the interpreter.")

;;;

;;; Indentation parameters

;;;

(defvar inform-indent-property 8

  "*Indentation of the start of a property declaration.")

(defvar inform-indent-has-with-class 1

  "*Indentation of has/with/class lines in object declarations.")

(defvar inform-indent-level 4

  "*Indentation of lines of block relative to first line of block.")

(defvar inform-indent-label-offset -3

  "*Indentation of label relative to where it should be.")

(defvar inform-indent-cont-statement 4

  "*Indentation of continuation relative to start of statement.")

(defvar inform-indent-fixup-space t

  "*If non-NIL, fix up space in object declarations.")

(defvar inform-indent-action-column 40

  "*Column at which action names should be placed in verb declarations.")

(defvar inform-comments-line-up-p nil

  "*If non-nil, comments spread over several lines will line up with the first.")

(defvar inform-strings-line-up-p nil

  "*Variable controlling indentation of multi-line strings.

If nil (default), string will be indented according to context.

If a number, will always set the indentation to that column.

If 'char', will line up with the first character of the string.

If 'quote', or other non-nil value, will line up with open quote on 

first line.")

;;;

;;; Syntax variables

;;;

(defvar inform-mode-syntax-table nil

  "Syntax table to use in Inform mode buffers.")

(if inform-mode-syntax-table

    nil

  (setq inform-mode-syntax-table (make-syntax-table))

  (modify-syntax-entry ?\\ "\\" inform-mode-syntax-table)

  (modify-syntax-entry ?\n ">" inform-mode-syntax-table)

  (modify-syntax-entry ?! "<" inform-mode-syntax-table)

  (modify-syntax-entry ?# "_" inform-mode-syntax-table)

  (modify-syntax-entry ?% "." inform-mode-syntax-table)

  (modify-syntax-entry ?& "." inform-mode-syntax-table)

  (modify-syntax-entry ?\' "." inform-mode-syntax-table)

  (modify-syntax-entry ?* "." inform-mode-syntax-table)

  (modify-syntax-entry ?- "." inform-mode-syntax-table)

  (modify-syntax-entry ?/ "." inform-mode-syntax-table)

  (modify-syntax-entry ?\; "." inform-mode-syntax-table)

  (modify-syntax-entry ?< "." inform-mode-syntax-table)

  (modify-syntax-entry ?= "." inform-mode-syntax-table)

  (modify-syntax-entry ?> "." inform-mode-syntax-table)

  (modify-syntax-entry ?+ "." inform-mode-syntax-table)

  (modify-syntax-entry ?| "." inform-mode-syntax-table)

  (modify-syntax-entry ?^ "w" inform-mode-syntax-table))

;;; Keyword definitions-------------------------------------------------------

;; These are used for syntax and font-lock purposes.

;; They combine words used in Inform 5 and Inform 6 for full compatability.

;; You can add new keywords directly to this list as the regexps for

;; font-locking are defined when this file is byte-compiled or eval'd.

(eval-and-compile

  (defvar inform-directive-list

    '("abbreviate" "array" "attribute" "btrace" "class" "constant"

      "default" "dictionary" "end" "endif" "etrace" "extend" "fake_action"

      "global" "ifdef" "ifndef" "iftrue" "iffalse" "ifv3" "ifv5" "import"

      "include" "link" "listsymbols" "listdict" "listverbs" "lowstring"

      "ltrace" "message" "nearby" "nobtrace" "noetrace" "noltrace" "notrace"

      "object" "property" "release" "replace" "serial" "statusline" "stub"

      "switches" "system_file" "trace" "verb" "zcharacter")

    "List of Inform directives that shouldn't appear embedded in code.")

  (defvar inform-defining-list

    '("[" "array" "attribute" "class" "constant" "fake_action" "global"

      "lowstring" "nearby" "object" "property")

    "List of Inform directives that define a variable/constant name.

Used to build a font-lock regexp; the name defined must follow the

keyword.")

  ;; We have to hardcode the regexp for inform-defining-list due to the way

  ;; regexp-opt works on different emacsen.

  ;; On Emacs 20 it always uses regular \( \) grouping

  ;; On Emacs 21 it always uses shy \(?: \) grouping

  ;; On XEmacs it can use either based on the shy parameter.

  ;; This means it is impossible to write a match-string expression in

  ;; inform-font-lock-keywords using regexp-opt that will work on all emacsen.

  ;; If Emacs 20 support is dropped this should be removed and shy grouping

  ;; used.

  (defvar inform-defining-list-regexp

    "\\[\\|a\\(rray\\|ttribute\\)\\|c\\(lass\\|onstant\\)\\|fake_action\\|global\\|lowstring\\|nearby\\|object\\|property"

    "Regexp based on inform-defining-list, hardcoded for portability.")

  (defvar inform-attribute-list

    '("absent" "animate" "clothing" "concealed" "container" "door"

      "edible" "enterable" "female" "general" "light" "lockable" "locked"

      "male" "moved" "neuter" "on" "open" "openable" "pluralname" "proper"

      "scenery" "scored" "static" "supporter" "switchable" "talkable"

      "transparent" "visited" "workflag" "worn")

    "List of Inform attributes defined in the library.")

  (defvar inform-property-list

    '("n_to" "s_to" "e_to" "w_to" "ne_to" "se_to" "nw_to" "sw_to" "u_to"

      "d_to" "in_to" "out_to" "add_to_scope" "after" "article" "articles"

      "before" "cant_go" "capacity" "daemon" "describe" "description"

      "door_dir" "door_to" "each_turn" "found_in" "grammar" "initial"

      "inside_description" "invent" "life" "list_together" "name" "number"

      "orders" "parse_name" "plural" "react_after" "react_before"

      "short_name" "time_left" "time_out" "when_closed" "when_open"

      "when_on" "when_off" "with_key")

    "List of Inform properties defined in the library.")

  (defvar inform-code-keyword-list

    '("box" "break" "continue" "do" "else" "font off" "font on" "for"

      "give" "has" "hasnt" "if" "inversion" "jump" "move" "new_line" "notin"

      "objectloop" "ofclass" "print" "print_ret" "quit" "read" "remove"

      "restore" "return" "rfalse" "rtrue" "save" "spaces" "string"

      "style bold" "style fixed" "style reverse" "style roman" "style underline"

      "switch" "to" "until" "while")

    "List of Inform code keywords.")

  )

;; Some regular expressions are needed at compile-time too so as to

;; avoid postponing the work to load time.

;; To do the work of building the regexps we use regexp-opt, which has

;; different behaviour on XEmacs and GNU Emacs and may not even be

;; available on ancient versions

(eval-and-compile

  (defun inform-make-regexp (strings &optional paren shy)

    (cond 

     ((string-match "XEmacs\\|Lucid" emacs-version)

      ;; XEmacs

      (regexp-opt strings paren shy))

     (t

      ;; GNU Emacs

      (regexp-opt strings)))))

(eval-and-compile

  (defvar inform-directive-regexp

    (concat "\\<#?\\("

            (inform-make-regexp inform-directive-list)

            "\\)\\>")

    "Regular expression matching an Inform directive.")

  (defvar inform-object-regexp

    "#?\\<\\(object\\|nearby\\|class\\)\\>"

    "Regular expression matching start of object declaration.")

  (defvar inform-property-regexp

    (concat "\\s-*\\("

            (inform-make-regexp inform-property-list)

            "\\)")

    "Regular expression matching Inform properties."))

(defvar inform-real-object-regexp

  (eval-when-compile (concat "^" inform-object-regexp))

  "Regular expression matching the start of a real object declaration.

That is, one found at the start of a line.")

(defvar inform-label-regexp "[^]:\"!\(\n]+\\(:\\|,\\)"

  "Regular expression matching a label.")

(defvar inform-action-regexp "\\s-*\\*"

  "Regular expression matching an action line in a verb declaration.")

(defvar inform-statement-terminators '(?\; ?{ ?} ?: ?\) do else)

  "Tokens which precede the beginning of a statement.")

;;;

;;; Font-lock keywords

;;;

(defvar inform-font-lock-defaults

  '(inform-font-lock-keywords nil t ((?_ . "w") (?' . "$")) inform-prev-object)

  "Font Lock defaults for Inform mode.")

(defface inform-dictionary-word-face

  '((((class color) (background light)) (:foreground "Red"))

    (((class color) (background dark)) (:foreground "Pink"))

    (t (:italic t :bold t)))

  "Font lock mode face used to highlight dictionary words.")

(defvar inform-dictionary-word-face 'inform-dictionary-word-face

  "Variable for Font lock mode face used to highlight dictionary words.")

(defvar inform-font-lock-keywords

  (eval-when-compile

    (list

     ;; Inform code keywords

     (cons (concat "\\s-\\("

                   (inform-make-regexp inform-code-keyword-list)

                   "\\)\\(\\s-\\|$\\|;\\)")

           '(1 font-lock-keyword-face))

     ;; Keywords that declare variable or constant names.

     (list 

      (concat "^#?\\("

              inform-defining-list-regexp

              "\\)\\s-+\\(->\\s-+\\)*\\(\\(\\w\\|\\s_\\)+\\)")

      '(1 font-lock-keyword-face)

      '(5 font-lock-function-name-face))

     ;; Other directives.

     (cons inform-directive-regexp 'font-lock-keyword-face)

     ;; Single quoted strings, length > 1, are dictionary words

     '("'\\(\\(-\\|\\w\\)\\(\\(-\\|\\w\\)+\\(//\\w*\\)?\\|//\\w*\\)\\)'"

       (1 inform-dictionary-word-face append))

     ;; Double-quoted dictionary words

     '("\\(\\s-name\\s-\\|^Verb\\|^Extend\\|^\\s-+\\*\\)"

       ("\"\\(\\(-\\|\\w\\)+\\)\"" nil nil

        (1 inform-dictionary-word-face t)))

     ;; More double-quoted dictionary words

     '("^\\s-+\"\\(\\(-\\|\\w\\)+\\)\"\\s-+\"\\(\\(-\\|\\w\\)+\\)\""

       (1 inform-dictionary-word-face t)

       (3 inform-dictionary-word-face t)

       ("\"\\(\\(-\\|\\w\\)+\\)\"" nil nil

        (1 inform-dictionary-word-face t)))

     ;; `private', `class', `has' and `with' in objects.

     '("^\\s-+\\(private\\|class\\|has\\|with\\)\\(\\s-\\|$\\)"

       (1 font-lock-keyword-face))

     ;; Attributes and properties.

     (cons (concat "[^#]\\<\\("

                   (inform-make-regexp (append inform-attribute-list

                                               inform-property-list))

                   "\\)\\>")

           '(1 font-lock-variable-name-face))))

  "Expressions to fontify in Inform mode.")

;;;

;;; Inform mode

;;;

(defun inform-mode ()

  "Major mode for editing Inform programs.

* Inform syntax:

  Type \\[indent-for-tab-command] to indent the current line.

  Type \\[indent-region] to indent the region.

  Type \\[fill-paragraph] to fill strings or comments.

  This compresses multiple spaces into single spaces.

* Multi-file projects:

  The variable `inform-project-file' gives the name of the root file of

  the project \(i.e., the one that you run Inform on\)\; it is best to

  set this as a local variable in each file, for example by making

     ! -*- inform-project-file:\"game.inf\" -*-

  the first line of the file.

* Tags tables:

  Type \\[inform-retagify] to build \(and load\) a Tags table.

  Type \\[visit-tags-table] to load an existing Tags table.

  If it exists, and if the variable `inform-autoload-tags' is non-NIL,

  the Tags table is loaded on entry to Inform Mode.

  With a Tags table loaded, type \\[find-tag] to find the declaration of

  the object, class or function under point.

* Navigating in a file:

  Type \\[inform-prev-object] to go to the previous object/class declaration.

  Type \\[inform-next-object] to go to the next one.

* Compilation:

  Type \\[inform-build-project] to build the current project.

  Type \\[next-error] to go to the next error.

* Running:

  Type \\[inform-run-project] to run the current project in an

  interpreter, either as a sepaarte process or in an Emacs terminal buffer.

* Font-lock support:

  Put \(add-hook 'inform-mode-hook 'turn-on-font-lock) in your .emacs.

* Spell checking:

  Type \\[inform-spell-check-buffer] to spell check all strings in the buffer.

  Type \\[ispell-word] to check the single word at point.

* Key definitions:

\\{inform-mode-map}

* Functions:

  inform-maybe-mode

    Looks at the contents of a file, guesses whether it is an Inform

    program, runs `inform-mode' if so, or `inform-maybe-other' if not.

    The latter defaults to `c-mode'.  Used for header files which might

    be Inform or C programs.

* Miscellaneous user options:

  inform-startup-message

    Set to nil to inhibit message first time Inform mode is used.

  inform-maybe-other

    The mode used by `inform-maybe-mode' if it guesses that the file is

    not an Inform program.

  inform-mode-hook

    This hook is run after entry to Inform Mode.

  inform-autoload-tags

    If non-nil, then a tags table will automatically be loaded when

    entering Inform mode.

  inform-auto-newline

    If non-nil, then newlines are automatically inserted before and

    after braces, and after semicolons in Inform code, and after commas

    in object declarations.

* User options controlling indentation style:

  Values in parentheses are the default indentation style.

  inform-indent-property \(8\)

    Indentation of a property or attribute in an object declaration.

  inform-indent-has-with-class \(1\)

    Indentation of has/with/class/private lines in object declaration.

  inform-indent-level \(4\)

    Indentation of line of code in a block relative to the first line of

    the block.

  inform-indent-label-offset \(-3\)

    Indentation of a line starting with a label, relative to the

    indentation if the label were absent.

  inform-indent-cont-statement \(4\)

    Indentation of second and subsequent lines of a statement, relative

    to the first.

  inform-indent-fixup-space \(T\)

    If non-NIL, fix up space after `Object', `Class', `Nearby', `has',

    `private' and `with', so that all the object's properties line up.

  inform-indent-action-column \(40\)

    Column at which action names should be placed in verb declarations.

    If NIL, then action names are not moved.

  inform-comments-line-up-p \(NIL\)

    If non-NIL, comments spread out over several lines will start on the

    same column as the first comment line.

  inform-strings-line-up-p \(NIL\)

    Variable controlling indentation of multi-line strings.

    If nil (default), string will be indented according to context.

    If a number, will always set the indentation to that column.

    If 'char', will line up with the first character of the string.

    If 'quote', or other non-nil value, will line up with open quote on 

    first line.

* User options to do with compilation:

  inform-command

    The shell command with which to run the Inform compiler.

  inform-libraries-directory

    If non-NIL, gives the directory in which the Inform libraries are

    found.

  inform-command-options

    Additional options with which to call the Inform compiler.

* User options to do with an interpreter:

  inform-interpreter-command

    The command with which to run the ZCode interpreter.  Can be a

    string (a command to be run), a symbol (name of function to call)

    or a function.

  inform-interpreter-options

    Additional options with which to call the ZCode interpreter.  Only

    used if `inform-interpreter-command' is a string.

  inform-interpreter-kill-old-process

    If non-NIL, `inform-run-project' will kill any running interpreter

    process and start a new one.  If not, will switch to the interpreter's

    buffer (if necessary - see documentation for `inform-run-project' for

    details).

  inform-interpreter-is-graphical

    If NIL, `inform-run-project' will switch to the interpreter buffer

    after running the interpreter.

* Please send any bugs or comments to rupert@rupert-lane.org

"

  (interactive)

  (if inform-startup-message

      (message "Emacs Inform mode version %s." inform-mode-version))

  (kill-all-local-variables)

  (use-local-map inform-mode-map)

  (set-syntax-table inform-mode-syntax-table)

  (make-local-variable 'comment-column)

  (make-local-variable 'comment-end)

  (make-local-variable 'comment-indent-function)

  (make-local-variable 'comment-start)

  (make-local-variable 'comment-start-skip)

  (make-local-variable 'fill-paragraph-function)

  (make-local-variable 'font-lock-defaults)

  (make-local-variable 'imenu-extract-index-name-function)

  (make-local-variable 'imenu-prev-index-position-function)

  (make-local-variable 'indent-line-function)

  (make-local-variable 'indent-region-function)

  (make-local-variable 'parse-sexp-ignore-comments)

  (make-local-variable 'require-final-newline)

  (setq comment-column 40

        comment-end ""

        comment-indent-function 'inform-comment-indent

        comment-start "!"

        comment-start-skip "!+\\s-*"

        fill-paragraph-function 'inform-fill-paragraph

        font-lock-defaults inform-font-lock-defaults

        imenu-extract-index-name-function 'inform-imenu-extract-name

        imenu-prev-index-position-function 'inform-prev-object

        indent-line-function 'inform-indent-line

        indent-region-function 'inform-indent-region

        inform-startup-message nil

        local-abbrev-table inform-mode-abbrev-table

        major-mode 'inform-mode

        mode-name "Inform"

        parse-sexp-ignore-comments t

        require-final-newline t)

  (auto-fill-mode 1)

  (if inform-autoload-tags

      (inform-auto-load-tags-table))

  (run-hooks 'inform-mode-hook))

(defun inform-maybe-mode ()

  "Starts Inform mode if file is in Inform; `inform-maybe-other' otherwise."

  (let ((case-fold-search t))

    (if (save-excursion

          (re-search-forward

           "^\\(!\\|object\\|nearby\\|\\[ \\)"

           nil t))

        (inform-mode)

      (funcall inform-maybe-other))))

;;;

;;; Syntax and indentation

;;;

;; Go to the start of the current Inform definition.  Just goes to the

;; most recent line with a function beginning [, or a directive.

(defun inform-beginning-of-defun ()

  (let ((case-fold-search t))

    (catch 'found

      (end-of-line 1)

      (while (re-search-backward "\n[[a-z]" nil 'move)

        (forward-char 1)

        (if (or (and (looking-at "\\[")

                     (eq (inform-preceding-char) ?\;))

                (looking-at inform-directive-regexp))

            (throw 'found nil))

        (forward-char -1)))))

;; Returns preceding non-blank, non-comment character in buffer.  It is

;; assumed that point is not inside a string or comment.

(defun inform-preceding-char ()

  (save-excursion

    (while (/= (point) (progn (forward-comment -1) (point))))

    (skip-syntax-backward " ")

    (if (bobp) ?\;

      (preceding-char))))

;; Returns preceding non-blank, non-comment token in buffer, either the

;; character itself, or the tokens 'do or 'else.  It is assumed that

;; point is not inside a string or comment.

(defun inform-preceding-token ()

  (save-excursion

    (while (/= (point) (progn (forward-comment -1) (point))))

    (skip-syntax-backward " ")

    (if (bobp) ?\;

      (let ((p (preceding-char)))

        (cond ((and (eq p ?o)

                    (>= (- (point) 2) (point-min)))

               (goto-char (- (point) 2))

               (if (looking-at "\\<do") 'do p))

              ((and (eq p ?e)

                    (>= (- (point) 4) (point-min)))

               (goto-char (- (point) 4))

               (if (looking-at "\\<else") 'else p))

              (t p))))))

;; `inform-syntax-class' returns a list describing the syntax at point.

;; Optional argument DEFUN-START gives the point from which parsing

;; should start, and DATA is the list returned by a previous invocation

;; of `inform-syntax-class'.

;; The returned list is of the form (SYNTAX IN-OBJ SEXPS STATE).

;; SYNTAX is one of

;;  directive  An Inform directive (given by `inform-directive-list')

;;  has        The "has" keyword

;;  with       The "with" keyword

;;  class      The "class" keyword

;;  private    The "private" keyword

;;  property   A property or attribute

;;  other      Any other line not in a function body

;;  string     The line begins inside a string

;;  comment    The line starts with a comment

;;  label      Line contains a label (i.e. has a colon in it)

;;  code       Any other line inside a function body

;;  blank      A blank line

;;  action     An action line in a verb declaration

;; IN-OBJ is non-NIL if the line appears to be inside an Object, Nearby,

;; or Class declaration.

;; SEXPS is a list of pairs (D . P) where P is the start of a sexp

;; containing point and D is its nesting depth.  The pairs are in

;; descreasing order of nesting depth.

;; STATE is the list returned by `parse-partial-sexp'.

;; For reasons of speed, `inform-syntax-class' looks for directives only

;; at the start of lines.  If the source contains top-level directives

;; not at the start of lines, or anything else at the start of a line

;; that might be mistaken for a directive, the wrong syntax class may be

;; returned.

;; There are circumstances in which SEXPS might not be complete (namely

;; if there were multiple opening brackets and some but not all have

;; been closed since the last call to `inform-syntax-class'), and rare

;; circumstances in which it might be wrong (namely if there are

;; multiple closing brackets and fewer, but at least two, opening

;; bracket since the last call).  I consider these cases not worth

;; worrying about - and the speed hit of checking for them is

;; considerable.

(defun inform-syntax-class (&optional defun-start data)

  (let ((line-start (point))

        in-obj state

        (case-fold-search t))

    (save-excursion

      (cond (defun-start

              (setq state (parse-partial-sexp defun-start line-start nil nil

                                              (nth 3 data)))

              (setq in-obj

                    (cond ((or (> (car state) 0) (nth 3 state) (nth 4 state))

                           (nth 1 data))

                          ((nth 1 data) (/= (inform-preceding-char) ?\;))

                          (t (looking-at inform-object-regexp)))))

            (t

             (inform-beginning-of-defun)

             (setq in-obj (looking-at inform-object-regexp)

                   state (parse-partial-sexp (point) line-start)))))

    (list

     (if (> (car state) 0)

         ;; If there's a containing sexp then it's easy.

         (cond ((nth 3 state) 'string)

               ((nth 4 state) 'comment)

               ((looking-at (concat "\\s-*" comment-start)) 'comment)

               ((looking-at inform-label-regexp) 'label)

               (t 'code))

       ;; Otherwise there are a bunch of special cases (has, with, class,

       ;; and private properties) that must be checked for.  Note that

       ;; we have to distinguish between global class declarations and

       ;; class membership in an object declaration.  This is done by

       ;; looking for a preceding semicolon.

       (cond ((nth 3 state) 'string)

             ((nth 4 state) 'comment)

             ((looking-at (concat "\\s-*" comment-start)) 'comment)

             ((and in-obj (looking-at "\\s-*class\\>")

                   (/= (inform-preceding-char) ?\;))

              'class)

             ((looking-at inform-action-regexp) 'action)

             ((looking-at inform-directive-regexp) 'directive)

             ((and (looking-at "\\[") (eq (inform-preceding-char) ?\;))

              'directive)

             ((and (not in-obj) (eq (inform-preceding-char) ?\;))

              'directive)

             ((looking-at "\\s-*$") 'blank)

             ((not in-obj) 'other)

             ((looking-at "\\s-*has\\(\\s-\\|$\\)") 'has)

             ((looking-at "\\s-*with\\(\\s-\\|$\\)") 'with)

             ((looking-at "\\s-*private\\(\\s-\\|$\\)") 'private)

             ((or (eq (inform-preceding-char) ?,)

                  (looking-at inform-property-regexp))

              'property)

             ;; This handles declarations of objects in a class eg

             ;; Bird "swallow";

             ;; It assumes that class names follow the convention of being

             ;; capitalised. This is not the most elegent way of handling

             ;; this case but in practice works well.

             ((looking-at "\\s-*[A-Z]")

              'directive)

             (t 

              'other)))

     ;; Are we in an object?

     (if (and in-obj

              (not (looking-at inform-object-regexp))

              (zerop (car state))

              (eq (inform-preceding-char) ?\;))

         nil

       in-obj)

     ;; List of known enclosing sexps.

     (let ((sexps (nth 2 data))         ; the old list of sexps

           (depth (car state))          ; current nesting depth

           (sexp-start (nth 1 state)))  ; enclosing sexp, if any

       (if sexps

           ;; Strip away closed sexps.

           (let ((sexp-depth (car (car sexps))))

             (while (and sexps (or (> sexp-depth depth)

                                   (and (eq sexp-depth depth)

                                        sexp-start)))

               (setq sexps (cdr sexps)

                     sexp-depth (if sexps (car (car sexps)))))))

       (if sexp-start

           (setq sexps (cons (cons depth sexp-start) sexps)))

       sexps)

     ;; State from the parse algorithm.

     state)))

;; Returns the correct indentation for the line at point.  DATA is the

;; syntax class for the start of the line (as returned by

;; `inform-syntax-class').  It is assumed that point is somewhere in the

;; indentation for the current line (i.e., everything to the left is

;; whitespace).

(defun inform-calculate-indentation (data)

  (let ((syntax (car data))             ; syntax class of start of line

        (in-obj (nth 1 data))           ; inside an object?

        (depth (car (nth 3 data)))      ; depth of nesting of start of line

        (case-fold-search t))           ; searches are case-insensitive

    (cond

     ;; Directives should never be indented or else the directive-

     ;; finding code won't run fast enough.  Hence the magic

     ;; constant 0.

     ((eq syntax 'directive) 0)

     ((eq syntax 'blank) 0)

     ;; Various standard indentations.

     ((eq syntax 'property) inform-indent-property)

     ((eq syntax 'other)

      (cond ((looking-at "\\s-*\\[") inform-indent-property)

            (in-obj (+ inform-indent-property inform-indent-level))

            (t inform-indent-level)))

     ((and (eq syntax 'string) (zerop depth))

      (cond (in-obj (+ inform-indent-property inform-indent-level))

            (t inform-indent-level)))

     ((and (eq syntax 'comment) (zerop depth))

      (inform-line-up-comment

       (if in-obj inform-indent-property 0)))

     ((eq syntax 'action) inform-indent-level)

     ((memq syntax '(has with class private)) inform-indent-has-with-class)

     ;; We are inside a sexp of some sort.

     (t

      (let ((indent 0)                  ; calculated indent column

            paren                       ; where the enclosing sexp begins

            string-start                ; where string (if any) starts

            (string-indent 0)           ; indentation for the current str

            cont-p                      ; true if line is a continuation

            paren-char                  ; the parenthesis character

            prec-token                  ; token preceding line

            this-char)                  ; character under consideration

        (save-excursion

          ;; Skip back to the start of a string, if any.  (Note that

          ;; we can't be in a comment since the syntax class applies

          ;; to the start of the line.)

          (if (eq syntax 'string)

              (progn

                (skip-syntax-backward "^\"")

                (forward-char -1)

                (setq string-start (point))

                (setq string-indent (current-column))

                ))

          ;; Now find the start of the sexp containing point.  Most

          ;; likely, the location was found by `inform-syntax-class';

          ;; if not, call `up-list' now and save the result in case

          ;; it's useful in future.

          (save-excursion

            (let ((sexps (nth 2 data)))

              (if (and sexps (eq (car (car sexps)) depth))

                  (goto-char (cdr (car sexps)))

                (up-list -1)

                (setcar (nthcdr 2 data)

                        (cons (cons depth (point)) (nth 2 data)))))

            (setq paren (point)

                  paren-char (following-char)))

          ;; If we were in a string, now skip back to the start of the

          ;; line.  We have to do this *after* calling `up-list' just

          ;; in case there was an opening parenthesis on the line