--- gforth/gforth.el	2001/05/18 15:27:21	1.50
+++ gforth/gforth.el	2003/02/08 15:28:39	1.65
@@ -1,6 +1,6 @@
 ;;; gforth.el --- major mode for editing (G)Forth sources
 
-;; Copyright (C) 1995,1996,1997,1998,2000 Free Software Foundation, Inc.
+;; Copyright (C) 1995,1996,1997,1998,2000,2001 Free Software Foundation, Inc.
 
 ;; This file is part of Gforth.
 
@@ -33,6 +33,7 @@
 ;; Changes by David
 ;; Added a syntax-hilighting engine, rewrote auto-indentation engine.
 ;; Added support for block files.
+;; Tested with Emacs 19.34, 20.5, 21.1 and XEmacs 21.1
  
 ;;-------------------------------------------------------------------
 ;; A Forth indentation, documentation search and interaction library
@@ -49,17 +50,149 @@
 
 ;;; Code:
 
- 
+;(setq debug-on-error t)
+
+;; Code ripped from `version.el' for compatability with Emacs versions
+;; prior to 19.23.
+(if (not (boundp 'emacs-major-version))
+    (defconst emacs-major-version
+      (progn (string-match "^[0-9]+" emacs-version)
+	     (string-to-int (match-string 0 emacs-version)))))
+
+(defun forth-emacs-older (major minor)
+  (or (< emacs-major-version major)
+      (and (= emacs-major-version major) (< emacs-minor-version minor))))
+
+;; Code ripped from `subr.el' for compatability with Emacs versions
+;; prior to 20.1
+(eval-when-compile 
+  (if (forth-emacs-older 20 1)
+      (progn
+	(defmacro when (cond &rest body)
+	  "If COND yields non-nil, do BODY, else return nil."
+	  (list 'if cond (cons 'progn body)))
+	(defmacro unless (cond &rest body)
+	  "If COND yields nil, do BODY, else return nil."
+	  (cons 'if (cons cond (cons nil body)))))))
+
+;; `no-error' argument of require not supported in Emacs versions
+;; prior to 20.4 :-(
+(defun forth-require (feature)
+  (condition-case err (require feature) (error nil)))
+
+(require 'font-lock)
+
+;; define `font-lock-warning-face' in emacs-versions prior to 20.1
+;; (ripped from `font-lock.el')
+(unless (boundp 'font-lock-warning-face)
+  (message "defining font-lock-warning-face")
+  (make-face 'font-lock-warning-face)
+  (defvar font-lock-warning-face 'font-lock-warning-face)
+  (set-face-foreground font-lock-warning-face "red")
+  (make-face-bold font-lock-warning-face))
+
+;; define `font-lock-constant-face' in XEmacs (just copy
+;; `font-lock-preprocessor-face')
+(unless (boundp 'font-lock-constant-face)
+  (copy-face font-lock-preprocessor-face 'font-lock-constant-face))
+
+
+;; define `regexp-opt' in emacs versions prior to 20.1 
+;; (this implementation is extremely inefficient, though)
+(eval-and-compile (forth-require 'regexp-opt))
+(unless (memq 'regexp-opt features)
+  (message (concat 
+	    "Warning: your Emacs version doesn't support `regexp-opt'. "
+            "Hilighting will be slow."))
+  (defun regexp-opt (STRINGS &optional PAREN)
+    (let ((open (if PAREN "\\(" "")) (close (if PAREN "\\)" "")))
+      (concat open (mapconcat 'regexp-quote STRINGS "\\|") close)))
+  (defun regexp-opt-depth (re)
+    (if (string= (substring re 0 2) "\\(") 1 0)))
+
+; todo:
+;
+
+; Wörter ordentlich hilighten, die nicht auf Whitespace beginnen ( ..)IF
+; -- mit aktueller Konzeption nicht möglich??
+;
+; Konfiguration über customization groups
+;
+; Bereich nur auf Wortanfang/ende ausweiten, wenn Anfang bzw Ende in einem 
+; Wort liegen (?) -- speed!
+;
+; 'forth-word' property muss eindeutig sein!
+;
+; Forth-Menu 
+;
+; Interface zu GForth Prozessen (Patches von Michael Scholz)
+;
+; Byte-compile-Code rausschmeißen, Compilieren im Makefile über Emacs
+; batch-Modus
+;
+; forth-help Kram rausschmeißen
+;
+; XEmacs Kompatibilität? imenu/speedbar -> fume?
+; 
+; Folding neuschreiben (neue Parser-Informationen benutzen)
 
-;;; Hilighting and indentation engine				(dk)
+;;; Motion-hooking (dk)
 ;;;
+(defun forth-idle-function ()
+  "Function that is called when Emacs is idle to detect cursor motion
+in forth-block-mode buffers (which is mainly used for screen number
+display in).  Currently ignores forth-mode buffers but that may change
+in the future."
+  (if (eq major-mode 'forth-block-mode)
+      (forth-check-motion)))
+
+(defvar forth-idle-function-timer nil 
+  "Timer that runs `forth-idle-function' or nil if no timer installed.")
+
+(defun forth-install-motion-hook ()
+  "Install the motion-hooking mechanism.  Currently uses idle timers
+but might be transparently changed in the future."
+  (unless forth-idle-function-timer
+    ;; install idle function only once (first time forth-mode is used)
+    (setq forth-idle-function-timer 
+	  (run-with-idle-timer .05 t 'forth-idle-function))))
+
+(defvar forth-was-point nil)
+
+(defun forth-check-motion ()
+  "Run `forth-motion-hooks', if `point' changed since last call.  This
+used to be called via `post-command-hook' but uses idle timers now as
+users complaint about lagging performance."
+  (when (or (eq forth-was-point nil) (/= forth-was-point (point)))
+    (setq forth-was-point (point))
+    (run-hooks 'forth-motion-hooks)))
+
+
+;;; Hilighting and indentation engine (dk)
+;;;
+(defvar forth-disable-parser nil
+  "*Non-nil means to disable on-the-fly parsing of Forth-code.
+
+This will disable hilighting of forth-mode buffers and will decrease
+the smartness of the indentation engine. Only set it to non-nil, if
+your computer is very slow. To disable hilighting, set
+`forth-hilight-level' to zero.")
+
+(defvar forth-jit-parser nil
+  "*Non-nil means to parse Forth-code just-in-time.
+
+This eliminates the need for initially parsing forth-mode buffers and
+thus speeds up loading of Forth files. That feature is only available
+in Emacs21 (and newer versions).")
 
 (defvar forth-words nil 
   "List of words for hilighting and recognition of parsed text areas. 
-You can enable hilighting of object-oriented Forth code, by appending either
-`forth-objects-words' or `forth-oof-words' to the list, depending on which
-OOP package you're using. After `forth-words' changed, `forth-compile-words' 
-must be called to make the changes take effect.
+
+Hilighting of object-oriented Forth code is achieved, by appending either
+`forth-objects-words' or `forth-oof-words' to the list, depending on the values of `forth-use-objects' or `forth-use-oof'.
+
+After `forth-words' changed, `forth-compile-words' must be called to
+make the changes take effect.
 
 Each item of `forth-words' has the form 
    (MATCHER TYPE HILIGHT . &optional PARSED-TEXT ...)
@@ -132,7 +265,8 @@ PARSED-TYPE specifies what kind of text
 	(("[ifdef]" "[ifundef]") immediate (font-lock-keyword-face . 2)
 	 "[ \t\n]" t name (font-lock-function-name-face . 3))
 	(("if" "begin" "ahead" "do" "?do" "+do" "u+do" "-do" "u-do" "for" 
-	  "case" "of" "?dup-if" "?dup-0=-if" "then" "until" "repeat" "again" 
+	  "case" "of" "?dup-if" "?dup-0=-if" "then" "endif" "until"
+	  "repeat" "again" "leave" "?leave"
 	  "loop" "+loop" "-loop" "next" "endcase" "endof" "else" "while" "try"
 	  "recover" "endtry" "assert(" "assert0(" "assert1(" "assert2(" 
 	  "assert3(" ")" "<interpretation" "<compilation" "interpretation>" 
@@ -141,13 +275,15 @@ PARSED-TYPE specifies what kind of text
 
 	(("true" "false" "c/l" "bl" "cell" "pi" "w/o" "r/o" "r/w") 
 	 non-immediate (font-lock-constant-face . 2))
-	(("~~") compile-only (font-lock-warning-face . 2))
+	(("~~" "break:" "dbg") compile-only (font-lock-warning-face . 2))
+	(("break\"") compile-only (font-lock-warning-face . 1)
+	 "[\"\n]" nil string (font-lock-string-face . 1))
 	(("postpone" "[is]" "defers" "[']" "[compile]") 
 	 compile-only (font-lock-keyword-face . 2)
 	 "[ \t\n]" t name (font-lock-function-name-face . 3))
 	(("is" "what's") immediate (font-lock-keyword-face . 2)
 	 "[ \t\n]" t name (font-lock-function-name-face . 3))
-	(("<is>" "'") non-immediate (font-lock-keyword-face . 2)
+	(("<is>" "'" "see") non-immediate (font-lock-keyword-face . 2)
 	 "[ \t\n]" t name (font-lock-function-name-face . 3))
 	(("[to]") compile-only (font-lock-keyword-face . 2)
 	 "[ \t\n]" t name (font-lock-variable-name-face . 3))
@@ -161,6 +297,7 @@ PARSED-TYPE specifies what kind of text
 	  "create-interpret/compile")
 	 non-immediate (font-lock-type-face . 2)
 	 "[ \t\n]" t name (font-lock-variable-name-face . 3))
+	("\\S-+%" non-immediate (font-lock-type-face . 2))
 	(("defer" "alias" "create-interpret/compile:") 
 	 non-immediate (font-lock-type-face . 1)
 	 "[ \t\n]" t name (font-lock-function-name-face . 3))
@@ -171,86 +308,147 @@ PARSED-TYPE specifies what kind of text
 	 immediate (font-lock-constant-face . 3))
 	))
 
-(defvar forth-objects-words nil
-  "Hilighting description for words of the \"Objects\" OOP package")
-(setq forth-objects-words 
-      '(((":m") definition-starter (font-lock-keyword-face . 1)
-	 "[ \t\n]" t name (font-lock-function-name-face . 3))
-	(("m:") definition-starter (font-lock-keyword-face . 1))
-	((";m") definition-ender (font-lock-keyword-face . 1))
-	(("[current]" "[parent]") compile-only (font-lock-keyword-face . 1)
-	 "[ \t\n]" t name (font-lock-function-name-face . 3))
-	(("current" "overrides") non-immediate (font-lock-keyword-face . 2)
-	 "[ \t\n]" t name (font-lock-function-name-face . 3))
-	(("[to-inst]") compile-only (font-lock-keyword-face . 2)
-	 "[ \t\n]" t name (font-lock-variable-name-face . 3))
-	(("[bind]") compile-only (font-lock-keyword-face . 2)
-	 "[ \t\n]" t name (font-lock-type-face . 3)
-	 "[ \t\n]" t name (font-lock-function-name-face . 3))
-	(("bind") non-immediate (font-lock-keyword-face . 2)
-	 "[ \t\n]" t name (font-lock-type-face . 3)
-	 "[ \t\n]" t name (font-lock-function-name-face . 3))
-	(("inst-var" "inst-value") non-immediate (font-lock-type-face . 2)
-	 "[ \t\n]" t name (font-lock-variable-name-face . 3))
-	(("method" "selector")
-	 non-immediate (font-lock-type-face . 1)
-	 "[ \t\n]" t name (font-lock-function-name-face . 3))
-	(("end-class" "end-interface")
-	 non-immediate (font-lock-keyword-face . 2)
-	 "[ \t\n]" t name (font-lock-type-face . 3))
-	(("public" "protected" "class" "exitm" "implementation" "interface"
-	  "methods" "end-methods" "this") 
-	 non-immediate (font-lock-keyword-face . 2))
-	(("object") non-immediate (font-lock-type-face . 2))))
-; (nconc forth-words forth-objects-words)
-
-(defvar forth-oof-words nil
-  "Hilighting description for words of the \"OOF\" OOP package")
-(setq forth-oof-words 
-      '((("class") non-immediate (font-lock-keyword-face . 2)
-	 "[ \t\n]" t name (font-lock-type-face . 3))
-	(("var") non-immediate (font-lock-type-face . 2)
-	 "[ \t\n]" t name (font-lock-variable-name-face . 3))
-	(("method") non-immediate (font-lock-type-face . 2)
-	 "[ \t\n]" t name (font-lock-function-name-face . 3))
-	(("::" "super" "bind" "bound" "link") 
-	 immediate (font-lock-keyword-face . 2)
-	 "[ \t\n]" t name (font-lock-function-name-face . 3))
-	(("ptr" "asptr" "[]") 
-	 immediate (font-lock-keyword-face . 2)
-	 "[ \t\n]" t name (font-lock-variable-name-face . 3))
-	(("class;" "how:" "self" "new" "new[]" "definitions" "class?" "with"
-	  "endwith")
-	 non-immediate (font-lock-keyword-face . 2))
-	(("object") non-immediate (font-lock-type-face . 2))))
-; (nconc forth-words forth-oof-words)
+(defvar forth-use-objects nil 
+  "*Non-nil makes forth-mode also hilight words from the \"Objects\" package.")
+(defvar forth-objects-words
+  '(((":m") definition-starter (font-lock-keyword-face . 1)
+     "[ \t\n]" t name (font-lock-function-name-face . 3))
+    (("m:") definition-starter (font-lock-keyword-face . 1))
+    ((";m") definition-ender (font-lock-keyword-face . 1))
+    (("[current]" "[parent]") compile-only (font-lock-keyword-face . 1)
+     "[ \t\n]" t name (font-lock-function-name-face . 3))
+    (("current" "overrides") non-immediate (font-lock-keyword-face . 2)
+     "[ \t\n]" t name (font-lock-function-name-face . 3))
+    (("[to-inst]") compile-only (font-lock-keyword-face . 2)
+     "[ \t\n]" t name (font-lock-variable-name-face . 3))
+    (("[bind]") compile-only (font-lock-keyword-face . 2)
+     "[ \t\n]" t name (font-lock-type-face . 3)
+     "[ \t\n]" t name (font-lock-function-name-face . 3))
+    (("bind") non-immediate (font-lock-keyword-face . 2)
+     "[ \t\n]" t name (font-lock-type-face . 3)
+     "[ \t\n]" t name (font-lock-function-name-face . 3))
+    (("inst-var" "inst-value") non-immediate (font-lock-type-face . 2)
+     "[ \t\n]" t name (font-lock-variable-name-face . 3))
+    (("method" "selector")
+     non-immediate (font-lock-type-face . 1)
+     "[ \t\n]" t name (font-lock-function-name-face . 3))
+    (("end-class" "end-interface")
+     non-immediate (font-lock-keyword-face . 2)
+     "[ \t\n]" t name (font-lock-type-face . 3))
+    (("public" "protected" "class" "exitm" "implementation" "interface"
+      "methods" "end-methods" "this") 
+     non-immediate (font-lock-keyword-face . 2))
+    (("object") non-immediate (font-lock-type-face . 2)))
+  "Hilighting description for words of the \"Objects\" package")
+
+
+(defvar forth-use-oof nil 
+  "*Non-nil makes forth-mode also hilight words from the \"OOF\" package.")
+(defvar forth-oof-words 
+  '((("class") non-immediate (font-lock-keyword-face . 2)
+     "[ \t\n]" t name (font-lock-type-face . 3))
+    (("var") non-immediate (font-lock-type-face . 2)
+     "[ \t\n]" t name (font-lock-variable-name-face . 3))
+    (("method" "early") non-immediate (font-lock-type-face . 2)
+     "[ \t\n]" t name (font-lock-function-name-face . 3))
+    (("::" "super" "bind" "bound" "link") 
+     immediate (font-lock-keyword-face . 2)
+     "[ \t\n]" t name (font-lock-function-name-face . 3))
+    (("ptr" "asptr" "[]") 
+     immediate (font-lock-keyword-face . 2)
+     "[ \t\n]" t name (font-lock-variable-name-face . 3))
+    (("class;" "how:" "self" "new" "new[]" "definitions" "class?" "with"
+      "endwith")
+     non-immediate (font-lock-keyword-face . 2))
+    (("object") non-immediate (font-lock-type-face . 2)))
+  "Hilighting description for words of the \"OOF\" package")
 
 (defvar forth-local-words nil 
   "List of Forth words to prepend to `forth-words'. Should be set by a 
-forth source, using a local variables list at the end of the file 
-(\"Local Variables: ... forth-local-words: ... End:\" construct).")
+ forth source, using a local variables list at the end of the file 
+ (\"Local Variables: ... forth-local-words: ... End:\" construct).") 
+
+(defvar forth-custom-words nil
+  "List of Forth words to prepend to `forth-words'. Should be set in your
+ .emacs.")
 
 (defvar forth-hilight-level 3 "*Level of hilighting of Forth code.")
+
 (defvar forth-compiled-words nil "Compiled representation of `forth-words'.")
 
-; todo:
-;
+(defvar forth-indent-words nil 
+  "List of words that have indentation behaviour.
+Each element of `forth-indent-words' should have the form
+   (MATCHER INDENT1 INDENT2 &optional TYPE) 
+  
+MATCHER is either a list of strings to match, or a REGEXP.
+   If it's a REGEXP, it should not be surrounded by `\\<` or `\\>`, since 
+   that'll be done automatically by the search routines.
 
-; Wörter ordentlich hilighten, die nicht auf whitespace beginning ( ..)IF
-; Additional `forth-use-objects' or
-; `forth-use-oof' could be set to non-nil for automatical adding of those
-; word-lists. Using local variable list?
-;
-; Konfiguration über customization groups
-;
-; Bereich nur auf Wortanfang/ende ausweiten, wenn anfang bzw ende in einem 
-; Wort liegen (?) -- speed!
-;
-; User interface
-;
-; 'forth-word' property muss eindeutig sein!
+TYPE might be omitted. If it's specified, the only allowed value is 
+   currently the symbol `non-immediate', meaning that the word will not 
+   have any effect on indentation inside definitions. (:NONAME is a good 
+   example for this kind of word).
+
+INDENT1 specifies how to indent a word that's located at the beginning
+   of a line, following any number of whitespaces.
+
+INDENT2 specifies how to indent words that are not located at the
+   beginning of a line.
+
+INDENT1 and INDENT2 are indentation specifications of the form
+   (SELF-INDENT . NEXT-INDENT), where SELF-INDENT is a numerical value, 
+   specifying how the matching line and all following lines are to be 
+   indented, relative to previous lines. NEXT-INDENT specifies how to indent 
+   following lines, relative to the matching line.
+  
+   Even values of SELF-INDENT and NEXT-INDENT correspond to multiples of
+   `forth-indent-level'. Odd values get an additional 
+   `forth-minor-indent-level' added/substracted. Eg a value of -2 indents
+   1 * forth-indent-level  to the left, wheras 3 indents 
+   1 * forth-indent-level + forth-minor-indent-level  columns to the right.")
+
+(setq forth-indent-words
+      '((("if" "begin" "do" "?do" "+do" "-do" "u+do"
+	  "u-do" "?dup-if" "?dup-0=-if" "case" "of" "try" 
+	  "[if]" "[ifdef]" "[ifundef]" "[begin]" "[for]" "[do]" "[?do]")
+	 (0 . 2) (0 . 2))
+	((":" ":noname" "code" "struct" "m:" ":m" "class" "interface")
+	 (0 . 2) (0 . 2) non-immediate)
+	("\\S-+%$" (0 . 2) (0 . 0) non-immediate)
+	((";" ";m") (-2 . 0) (0 . -2))
+	(("again" "then" "endif" "endtry" "endcase" "endof" 
+	  "[then]" "[endif]" "[loop]" "[+loop]" "[next]" 
+	  "[until]" "[again]" "loop")
+	 (-2 . 0) (0 . -2))
+	(("end-code" "end-class" "end-interface" "end-class-noname" 
+	  "end-interface-noname" "end-struct" "class;")
+	 (-2 . 0) (0 . -2) non-immediate)
+	(("protected" "public" "how:") (-1 . 1) (0 . 0) non-immediate)
+	(("+loop" "-loop" "until") (-2 . 0) (-2 . 0))
+	(("else" "recover" "[else]") (-2 . 2) (0 . 0))
+	(("does>") (-1 . 1) (0 . 0))
+	(("while" "[while]") (-2 . 4) (0 . 2))
+	(("repeat" "[repeat]") (-4 . 0) (0 . -4))
+	(("\\g") (-2 . 2) (0 . 0))))
 
-(setq debug-on-error t)
+(defvar forth-local-indent-words nil 
+  "List of Forth words to prepend to `forth-indent-words', when a forth-mode
+buffer is created. Should be set by a Forth source, using a local variables 
+list at the end of the file (\"Local Variables: ... forth-local-words: ... 
+End:\" construct).")
+
+(defvar forth-custom-indent-words nil
+  "List of Forth words to prepend to `forth-indent-words'. Should be set in
+ your .emacs.")
+
+(defvar forth-indent-level 4
+  "*Indentation of Forth statements.")
+(defvar forth-minor-indent-level 2
+  "*Minor indentation of Forth statements.")
+(defvar forth-compiled-indent-words nil)
+
+;(setq debug-on-error t)
 
 ;; Filter list by predicate. This is a somewhat standard function for 
 ;; functional programming languages. So why isn't it already implemented 
@@ -277,11 +475,14 @@ forth source, using a local variables li
 ;; Helper function for `forth-compile-word': translate one entry from 
 ;; `forth-words' into the form  (regexp regexp-depth word-description)
 (defun forth-compile-words-mapper (word)
+  ;; warning: we cannot rely on regexp-opt's PAREN argument, since
+  ;; XEmacs will use shy parens by default :-(
   (let* ((matcher (car word))
-	 (regexp (if (stringp matcher) (concat "\\(" matcher "\\)")
-		   (if (listp matcher) (regexp-opt matcher t)
-		     (error "Invalid matcher (stringp or listp expected `%s'" 
-			    matcher))))
+	 (regexp 
+	  (concat "\\(" (cond ((stringp matcher) matcher)
+			      ((listp matcher) (regexp-opt matcher))
+			      (t (error "Invalid matcher `%s'")))
+		  "\\)"))
 	 (depth (regexp-opt-depth regexp))
 	 (description (cdr word)))
     (list regexp depth description)))
@@ -310,7 +511,7 @@ forth source, using a local variables li
 (defun forth-compile-words ()
   "Compile the the words from `forth-words' and `forth-indent-words' into
  the format that's later used for doing the actual hilighting/indentation.
-Store the resulting compiled wordlists in `forth-compiled-words' and 
+ Store the resulting compiled wordlists in `forth-compiled-words' and 
 `forth-compiled-indent-words', respective"
   (setq forth-compiled-words 
 	(forth-compile-wordlist 
@@ -319,14 +520,27 @@ Store the resulting compiled wordlists i
 	(forth-compile-wordlist forth-indent-words)))
 
 (defun forth-hack-local-variables ()
-  "Parse and bind local variables, set in the contens of the current 
-forth-mode buffer. Prepend `forth-local-words' to `forth-words' and 
-`forth-local-indent-words' to `forth-local-words'."
+  "Parse and bind local variables, set in the contents of the current 
+ forth-mode buffer. Prepend `forth-local-words' to `forth-words' and 
+ `forth-local-indent-words' to `forth-indent-words'."
   (hack-local-variables)
   (setq forth-words (append forth-local-words forth-words))
   (setq forth-indent-words (append forth-local-indent-words 
 				   forth-indent-words)))
 
+(defun forth-customize-words ()
+  "Add the words from `forth-custom-words' and `forth-custom-indent-words'
+ to `forth-words' and `forth-indent-words', respective. Add 
+ `forth-objects-words' and/or `forth-oof-words' to `forth-words', if
+ `forth-use-objects' and/or `forth-use-oof', respective is set."
+  (setq forth-words (append forth-custom-words forth-words
+			    (if forth-use-oof forth-oof-words nil)
+			    (if forth-use-objects forth-objects-words nil)))
+  (setq forth-indent-words (append 
+			    forth-custom-indent-words forth-indent-words)))
+
+
+
 ;; get location of first character of previous forth word that's got 
 ;; properties
 (defun forth-previous-start (pos)
@@ -367,13 +581,15 @@ forth-mode buffer. Prepend `forth-local-
 ;; Delete all properties, used by Forth mode, from `from' to `to'.
 (defun forth-delete-properties (from to)
   (remove-text-properties 
-   from to '(face nil forth-parsed nil forth-word nil forth-state nil)))
+   from to '(face nil fontified nil 
+		  forth-parsed nil forth-word nil forth-state nil)))
 
 ;; Get the index of the branch of the most recently evaluated regular 
 ;; expression that matched. (used for identifying branches "a\\|b\\|c...")
 (defun forth-get-regexp-branch ()
   (let ((count 2))
-    (while (not (match-beginning count))
+    (while (not (condition-case err (match-beginning count)
+		  (args-out-of-range t)))  ; XEmacs requires error handling
       (setq count (1+ count)))
     count))
 
@@ -435,11 +651,9 @@ forth-mode buffer. Prepend `forth-local-
 ;; Search for known Forth words in the range `from' to `to', using 
 ;; `forth-next-known-forth-word' and set their properties via 
 ;; `forth-set-word-properties'.
-(defun forth-update-properties (from to)
+(defun forth-update-properties (from to &optional loudly)
   (save-excursion
-    (let ((msg-flag nil) (state) (word-descr) (last-location))
-      (when (> to (+ from 5000))
-	(setq msg-flag t) (message "Parsing Forth code..."))
+    (let ((msg-count 0) (state) (word-descr) (last-location))
       (goto-char (forth-previous-word (forth-previous-start 
 				       (max (point-min) (1- from)))))
       (setq to (forth-next-end (min (point-max) (1+ to))))
@@ -448,8 +662,14 @@ forth-mode buffer. Prepend `forth-local-
       (setq state (get-text-property (point) 'forth-state))
       (setq last-location (point))
       (forth-delete-properties (point) to)
+      (put-text-property (point) to 'fontified t)
       ;; hilight loop...
       (while (setq word-descr (forth-next-known-forth-word to))
+	(when loudly
+	  (when (equal 0 (% msg-count 100))
+	    (message "Parsing Forth code...%s"
+		     (make-string (/ msg-count 100) ?.)))
+	  (setq msg-count (1+ msg-count)))
 	(forth-set-word-properties state word-descr)
 	(when state (put-text-property last-location (point) 'forth-state t))
 	(let ((type (car word-descr)))
@@ -466,7 +686,6 @@ forth-mode buffer. Prepend `forth-local-
 				to 'forth-state (current-buffer) (point-max))))
 		(forth-update-properties to extend-to))
 	    ))
-      (when msg-flag (message "Parsing Forth code...done"))
       )))
 
 ;; save-buffer-state borrowed from `font-lock.el'
@@ -485,14 +704,21 @@ forth-mode buffer. Prepend `forth-local-
 ;; Function that is added to the `change-functions' hook. Calls 
 ;; `forth-update-properties' and keeps care of disabling undo information
 ;; and stuff like that.
-(defun forth-change-function (from to len)
+(defun forth-change-function (from to len &optional loudly)
+  (save-match-data
+    (forth-save-buffer-state 
+     () 
+     (unless forth-disable-parser (forth-update-properties from to loudly))
+     (forth-update-warn-long-lines))))
+
+(defun forth-fontification-function (from)
+  "Function to be called from `fontification-functions' of Emacs 21."
   (save-match-data
-    (forth-save-buffer-state () 
-     (unwind-protect 
-	 (progn 
-	   (forth-update-properties from to)
-	   (forth-update-show-screen)
-	   (forth-update-warn-long-lines))))))
+    (forth-save-buffer-state
+     ((to (min (point-max) (+ from 100))))
+     (unless (or forth-disable-parser (not forth-jit-parser)
+		 (get-text-property from 'fontified))
+       (forth-update-properties from to)))))
 
 (eval-when-compile
   (byte-compile 'forth-set-word-properties)
@@ -501,69 +727,54 @@ forth-mode buffer. Prepend `forth-local-
   (byte-compile 'forth-delete-properties)
   (byte-compile 'forth-get-regexp-branch)) 
 
+;;; imenu support
+;;;
+(defvar forth-defining-words 
+  '("VARIABLE" "CONSTANT" "2VARIABLE" "2CONSTANT" "FVARIABLE" "FCONSTANT"
+   "USER" "VALUE" "field" "end-struct" "VOCABULARY" "CREATE" ":" "CODE"
+   "DEFER" "ALIAS")
+  "List of words, that define the following word.
+Used for imenu index generation.")
+
+(defvar forth-defining-words-regexp nil 
+  "Regexp that's generated for matching `forth-defining-words'")
+ 
+(defun forth-next-definition-starter ()
+  (progn
+    (let* ((pos (re-search-forward forth-defining-words-regexp (point-max) t)))
+      (if pos
+	  (if (or (text-property-not-all (match-beginning 0) (match-end 0) 
+					 'forth-parsed nil)
+		  (text-property-not-all (match-beginning 0) (match-end 0)
+					 'forth-state nil)) 
+	      (forth-next-definition-starter)
+	    t)
+	nil))))
+
+(defun forth-create-index ()
+  (let* ((forth-defining-words-regexp 
+	  (concat "\\<\\(" (regexp-opt forth-defining-words) "\\)\\>"))
+	 (index nil))
+    (goto-char (point-min))
+    (while (forth-next-definition-starter)
+      (if (looking-at "[ \t]*\\([^ \t\n]+\\)")
+	  (setq index (cons (cons (match-string 1) (point)) index))))
+    index))
+
+;; top-level require is executed at byte-compile and load time
+(eval-and-compile (forth-require 'speedbar))
+
+;; this code is executed at load-time only
+(when (memq 'speedbar features)
+  (speedbar-add-supported-extension ".fs")
+  (speedbar-add-supported-extension ".fb"))
+
 ;; (require 'profile)
 ;; (setq profile-functions-list '(forth-set-word-properties forth-next-known-forth-word forth-update-properties forth-delete-properties forth-get-regexp-branch))
 
 ;;; Indentation
 ;;;
 
-(defvar forth-indent-words nil 
-  "List of words that have indentation behaviour.
-Each element of `forth-indent-words' should have the form
-   (MATCHER INDENT1 INDENT2) 
-  
-MATCHER is either a list of strings to match, or a REGEXP.
-   If it's a REGEXP, it should not be surrounded by `\\<` or `\\>`, since 
-   that'll be done automatically by the search routines.
-
-INDENT1 specifies how to indent a word that's located at a line's begin,
-   following any number of whitespaces.
-
-INDENT2 specifies how to indent words that are not located at a line's begin.
-
-INDENT1 and INDENT2 are indentation specifications of the form
-   (SELF-INDENT . NEXT-INDENT), where SELF-INDENT is a numerical value, 
-   specifying how the matching line and all following lines are to be 
-   indented, relative to previous lines. NEXT-INDENT specifies how to indent 
-   following lines, relative to the matching line.
-  
-   Even values of SELF-INDENT and NEXT-INDENT correspond to multiples of
-   `forth-indent-level'. Odd values get an additional 
-   `forth-minor-indent-level' added/substracted. Eg a value of -2 indents
-   1 * forth-indent-level  to the left, wheras 3 indents 
-   1 * forth-indent-level + forth-minor-indent-level  columns to the right.")
-
-(setq forth-indent-words
-      '(((":" ":noname" "code" "if" "begin" "do" "?do" "+do" "-do" "u+do"
-	  "u-do" "?dup-if" "?dup-0=-if" "case" "of" "try" "struct" 
-	  "[if]" "[ifdef]" "[ifundef]" "[begin]" "[for]" "[do]" "[?do]"
-	  "class" "interface" "m:" ":m")
-	 (0 . 2) (0 . 2))
-	((";" ";m") (-2 . 0) (0 . -2))
-	(("end-code" "again" "repeat" "then" "endtry" "endcase" "endof" 
-	  "end-struct" "[then]" "[endif]" "[loop]" "[+loop]" "[next]" 
-	  "[until]" "[repeat]" "[again]" "end-class" "end-interface"
-	  "end-class-noname" "end-interface-noname" "loop"
-	  "class;")
-	 (-2 . 0) (0 . -2))
-	(("protected" "public" "how:") (-1 . 1) (0 . 0))
-	(("+loop" "-loop" "until") (-2 . 0) (-2 . 0))
-	(("else" "recover" "[else]") (-2 . 2) (0 . 0))
-	(("while" "does>" "[while]") (-1 . 1) (0 . 0))
-	(("\\g") (-2 . 2) (0 . 0))))
-
-(defvar forth-local-indent-words nil 
-  "List of Forth words to prepend to `forth-indent-words', when a forth-mode
-buffer is created. Should be set by a Forth source, using a local variables 
-list at the end of the file (\"Local Variables: ... forth-local-words: ... 
-End:\" construct).")
-
-(defvar forth-indent-level 4
-  "Indentation of Forth statements.")
-(defvar forth-minor-indent-level 2
-  "Minor indentation of Forth statements.")
-(defvar forth-compiled-indent-words nil)
-
 ;; Return, whether `pos' is the first forth word on its line
 (defun forth-first-word-on-line-p (pos)
   (save-excursion
@@ -581,12 +792,19 @@ End:\" construct).")
 	(let* ((regexp (car forth-compiled-indent-words))
 	       (pos (re-search-forward regexp to t)))
 	  (if pos
-	      (if (text-property-not-all (match-beginning 0) (match-end 0) 
-					 'forth-parsed nil)
-		  (forth-next-known-indent-word to)
-		(let* ((branch (forth-get-regexp-branch))
-		       (descr (cdr forth-compiled-indent-words))
-		       (indent (cdr (assoc branch descr))))
+	      (let* ((start (match-beginning 0))
+		     (end (match-end 0))
+		     (branch (forth-get-regexp-branch))
+		     (descr (cdr forth-compiled-indent-words))
+		     (indent (cdr (assoc branch descr)))
+		     (type (nth 2 indent)))
+		;; skip words that are parsed (strings/comments) and 
+		;; non-immediate words inside definitions
+		(if (or (text-property-not-all start end 'forth-parsed nil)
+			(and (eq type 'non-immediate) 
+			     (text-property-not-all start end 
+						    'forth-state nil)))
+		    (forth-next-known-indent-word to)
 		  (if (forth-first-word-on-line-p (match-beginning 0))
 		      (nth 0 indent) (nth 1 indent))))
 	    nil)))
@@ -634,8 +852,7 @@ End:\" construct).")
 (defun forth-get-anchor-column ()
   (save-excursion
     (if (/= 0 (forward-line -1)) 0
-      (let ((next-indent)
-	    (self-indent))
+      (let ((indent))
 	(while (not (or (setq indent (forth-get-column-incr 1))
 			(<= (point) (point-min))))
 	  (forward-line -1))
@@ -694,7 +911,6 @@ End:\" construct).")
   (forth-newline-remove-trailing)
   (indent-according-to-mode))
 
-;;; end hilighting/indentation
 
 ;;; Block file encoding/decoding  (dk)
 ;;;
@@ -798,7 +1014,7 @@ done by checking whether the first line
   (save-restriction 
     (widen)
     (save-excursion
-       (beginning-of-buffer)
+       (goto-char (point-min))
        (end-of-line)
        (>= (current-column) 1024))))
 
@@ -822,6 +1038,7 @@ done by checking whether the first line
   "Non-nil means to warn about lines that are longer than 64 characters")
 
 (defvar forth-screen-marker nil)
+(defvar forth-screen-number-string nil)
 
 (defun forth-update-show-screen ()
   "If `forth-show-screen' is non-nil, put overlay arrow to start of screen, 
@@ -851,7 +1068,7 @@ exceeds 64 characters."
 	       forth-c/l))))
 
 (add-hook 'forth-motion-hooks 'forth-update-warn-long-lines)
-    
+
 ;;; End block file editing
 
 
@@ -878,57 +1095,35 @@ exceeds 64 characters."
 (define-key forth-mode-map "\M-q" 'forth-fill-paragraph)
 (define-key forth-mode-map "\e." 'forth-find-tag)
 
-;;; hook into motion events (realy ugly!)  (dk)
-(define-key forth-mode-map "\C-n" 'forth-next-line)
-(define-key forth-mode-map "\C-p" 'forth-previous-line)
-(define-key forth-mode-map [down] 'forth-next-line)
-(define-key forth-mode-map [up] 'forth-previous-line)
-(define-key forth-mode-map "\C-f" 'forth-forward-char)
-(define-key forth-mode-map "\C-b" 'forth-backward-char)
-(define-key forth-mode-map [right] 'forth-forward-char)
-(define-key forth-mode-map [left] 'forth-backward-char)
-(define-key forth-mode-map "\M-f" 'forth-forward-word)
-(define-key forth-mode-map "\M-b" 'forth-backward-word)
-(define-key forth-mode-map [C-right] 'forth-forward-word)
-(define-key forth-mode-map [C-left] 'forth-backward-word)
-(define-key forth-mode-map "\M-v" 'forth-scroll-down)
-(define-key forth-mode-map "\C-v" 'forth-scroll-up)
-(define-key forth-mode-map [prior] 'forth-scroll-down)
-(define-key forth-mode-map [next] 'forth-scroll-up)
-
-(defun forth-next-line (arg) 
-  (interactive "p") (next-line arg) (run-hooks 'forth-motion-hooks))
-(defun forth-previous-line (arg)
-  (interactive "p") (previous-line arg) (run-hooks 'forth-motion-hooks))
-(defun forth-backward-char (arg)
-  (interactive "p") (backward-char arg) (run-hooks 'forth-motion-hooks))
-(defun forth-forward-char (arg)
-  (interactive "p") (forward-char arg) (run-hooks 'forth-motion-hooks))
-(defun forth-forward-word (arg)
-  (interactive "p") (forward-word arg) (run-hooks 'forth-motion-hooks))
-(defun forth-backward-word (arg)
-  (interactive "p") (backward-word arg) (run-hooks 'forth-motion-hooks))
-(defun forth-scroll-down (arg)
-  (interactive "P") (scroll-down arg) (run-hooks 'forth-motion-hooks))
-(defun forth-scroll-up (arg)
-  (interactive "P") (scroll-up arg) (run-hooks 'forth-motion-hooks))
-
-;setup for C-h C-i to work
-(if (fboundp 'info-lookup-add-help)
-    (info-lookup-add-help
-     :topic 'symbol
-     :mode 'forth-mode
-     :regexp "[^ 	
-]+"
-     :ignore-case t
-     :doc-spec '(("(gforth)Name Index" nil "`" "'  "))))
+;; setup for C-h C-i to work
+(eval-and-compile (forth-require 'info-look))
+(when (memq 'info-look features)
+  (defvar forth-info-lookup '(symbol (forth-mode "\\S-+" t 
+						  (("(gforth)Word Index"))
+						  "\\S-+")))
+  (unless (memq forth-info-lookup info-lookup-alist)
+    (setq info-lookup-alist (cons forth-info-lookup info-lookup-alist)))
+  ;; in X-Emacs C-h C-i is by default bound to Info-query
+  (define-key forth-mode-map "\C-h\C-i" 'info-lookup-symbol))
+
+
+;;   (info-lookup-add-help
+;;    :topic 'symbol
+;;    :mode 'forth-mode
+;;    :regexp "[^ 	
+;; ]+"
+;;    :ignore-case t
+;;    :doc-spec '(("(gforth)Name Index" nil "`" "'  "))))
 
-(load "etags")
+(require 'etags)
 
 (defun forth-find-tag (tagname &optional next-p regexp-p)
   (interactive (find-tag-interactive "Find tag: "))
+  (unless (or regexp-p next-p)
+    (setq tagname (concat "\\(^\\|\\s-\\)\\(" (regexp-quote tagname) 
+			    "\\)\\(\\s-\\|$\\)")))
   (switch-to-buffer
-   (find-tag-noselect (concat " " tagname " ") next-p regexp-p)))
+   (find-tag-noselect tagname next-p t)))
 
 (defvar forth-mode-syntax-table nil
   "Syntax table in use in Forth-mode buffers.")
@@ -949,7 +1144,6 @@ exceeds 64 characters."
 	  (setq char (1+ char))))
       ))
 
-
 (defun forth-mode-variables ()
   (set-syntax-table forth-mode-syntax-table)
   (setq local-abbrev-table forth-mode-abbrev-table)
@@ -968,12 +1162,14 @@ exceeds 64 characters."
   (make-local-variable 'comment-column)
   (setq comment-column 40)
   (make-local-variable 'comment-start-skip)
-  (setq comment-start-skip "\\ ")
-  (make-local-variable 'comment-indent-hook)
-  (setq comment-indent-hook 'forth-comment-indent)
+  (setq comment-start-skip "\\\\ ")
+  (make-local-variable 'comment-indent-function)
+  (setq comment-indent-function 'forth-comment-indent)
   (make-local-variable 'parse-sexp-ignore-comments)
   (setq parse-sexp-ignore-comments t)
   (setq case-fold-search t)
+  (make-local-variable 'forth-was-point)
+  (setq forth-was-point -1)
   (make-local-variable 'forth-words)
   (make-local-variable 'forth-compiled-words)
   (make-local-variable 'forth-compiled-indent-words)
@@ -983,8 +1179,13 @@ exceeds 64 characters."
   (make-local-variable 'forth-screen-marker)
   (make-local-variable 'forth-warn-long-lines)
   (make-local-variable 'forth-screen-number-string)
+  (make-local-variable 'forth-use-oof)
+  (make-local-variable 'forth-use-objects) 
   (setq forth-screen-marker (copy-marker 0))
-  (add-hook 'after-change-functions 'forth-change-function))
+  (add-hook 'after-change-functions 'forth-change-function)
+  (if (and forth-jit-parser (>= emacs-major-version 21))
+      (add-hook 'fontification-functions 'forth-fontification-function))
+  (setq imenu-create-index-function 'forth-create-index))
 
 ;;;###autoload
 (defun forth-mode ()
@@ -1023,7 +1224,18 @@ Variables controlling interaction and st
 Variables controlling syntax hilighting/recognition of parsed text:
  `forth-words'
     List of words that have a special parsing behaviour and/or should be
-    hilighted.
+    hilighted. Add custom words by setting forth-custom-words in your
+    .emacs, or by setting forth-local-words, in source-files' local 
+    variables lists.
+ forth-use-objects
+    Set this variable to non-nil in your .emacs, or in a local variables 
+    list, to hilight and recognize the words from the \"Objects\" package 
+    for object-oriented programming.
+ forth-use-oof
+    Same as above, just for the \"OOF\" package.
+ forth-custom-words
+    List of custom Forth words to prepend to `forth-words'. Should be set
+    in your .emacs.
  forth-local-words
     List of words to prepend to `forth-words', whenever a forth-mode
     buffer is created. That variable should be set by Forth sources, using
@@ -1034,39 +1246,37 @@ Variables controlling syntax hilighting/
        forth-local-words: ...
        End:
     [THEN]
- forth-objects-words
-    Hilighting information for the words of the \"Objects\" package for 
-    object-oriented programming. Append it to `forth-words', if you need 
-    it.
- forth-oof-words
-    Hilighting information for the words of the \"OOF\" package.
  forth-hilight-level
     Controls how much syntax hilighting is done. Should be in the range 
+    0..3
 
 Variables controlling indentation style:
  `forth-indent-words'
     List of words that influence indentation.
- `forth-local-indent-words'
+ forth-local-indent-words
     List of words to prepend to `forth-indent-words', similar to 
-    `forth-local-words'. Should be used for specifying file-specific 
+    forth-local-words. Should be used for specifying file-specific 
     indentation, using a local variables list.
+ forth-custom-indent-words
+    List of words to prepend to `forth-indent-words'. Should be set in your
+    .emacs.    
  forth-indent-level
     Indentation increment/decrement of Forth statements.
  forth-minor-indent-level
     Minor indentation increment/decrement of Forth statemens.
 
 Variables controlling block-file editing:
- `forth-show-screen'
+ forth-show-screen
     Non-nil means, that the start of the current screen is marked by an
     overlay arrow, and screen numbers are displayed in the mode line.
     This variable is by default nil for `forth-mode' and t for 
     `forth-block-mode'.
- `forth-overlay-arrow-string'
+ forth-overlay-arrow-string
     String to display as the overlay arrow, when `forth-show-screen' is t.
     Setting this variable to nil disables the overlay arrow.
- `forth-block-base'
+ forth-block-base
     Screen number of the first block in a block file. Defaults to 1.
- `forth-warn-long-lines'
+ forth-warn-long-lines
     Non-nil means that a warning message is displayed whenever you edit or
     move over a line that is longer than 64 characters (the maximum line
     length that can be stored into a block file). This variable defaults to
@@ -1088,6 +1298,7 @@ Variables controling documentation searc
   (use-local-map forth-mode-map)
   (setq mode-name "Forth")
   (setq major-mode 'forth-mode)
+  (forth-install-motion-hook)
   ;; convert buffer contents from block file format, if necessary
   (when (forth-detect-block-file-p)
     (widen)
@@ -1135,8 +1346,10 @@ bell during block file read/write operat
 	 (make-local-variable 'compile-command)
 	 (setq compile-command "gforth ")
 	 (forth-hack-local-variables)
+	 (forth-customize-words)
 	 (forth-compile-words)
-	 (forth-change-function (point-min) (point-max) nil)))
+	 (unless (and forth-jit-parser (>= emacs-major-version 21))
+	   (forth-change-function (point-min) (point-max) nil t))))
 
 (defun forth-fill-paragraph () 
   "Fill comments (starting with '\'; do not fill code (block style
@@ -1661,7 +1874,7 @@ The region is sent terminated by a newli
 
 (define-key forth-mode-map "\C-x\C-e" 'compile)
 (define-key forth-mode-map "\C-x\C-n" 'next-error)
-(require 'compile "compile")
+(require 'compile)
 
 (defvar forth-compile-command "gforth ")
 ;(defvar forth-compilation-window-percent-height 30)
@@ -1676,30 +1889,34 @@ The region is sent terminated by a newli
 ;;; Forth menu
 ;;; Mikael Karlsson <qramika@eras70.ericsson.se>
 
-(cond ((string-match "XEmacs\\|Lucid" emacs-version)
-       (require 'func-menu)
-
-  (defconst fume-function-name-regexp-forth
-   "^\\(:\\)[ \t]+\\([^ \t]*\\)"
-   "Expression to get word definitions in Forth.")
-
-  (setq fume-function-name-regexp-alist
-      (append '((forth-mode . fume-function-name-regexp-forth) 
-             ) fume-function-name-regexp-alist))
-
-  ;; Find next forth word in the buffer
-  (defun fume-find-next-forth-function-name (buffer)
-    "Searches for the next forth word in BUFFER."
-    (set-buffer buffer)
-    (if (re-search-forward fume-function-name-regexp nil t)
-      (let ((beg (match-beginning 2))
-            (end (match-end 2)))
-        (cons (buffer-substring beg end) beg))))
+;; (dk) code commented out due to complaints of XEmacs users.  After
+;; all, there's imenu/speedbar, which uses much smarter scanning
+;; rules.
+
+;; (cond ((string-match "XEmacs\\|Lucid" emacs-version)
+;;        (require 'func-menu)
+
+;;   (defconst fume-function-name-regexp-forth
+;;    "^\\(:\\)[ \t]+\\([^ \t]*\\)"
+;;    "Expression to get word definitions in Forth.")
+
+;;   (setq fume-function-name-regexp-alist
+;;       (append '((forth-mode . fume-function-name-regexp-forth) 
+;;              ) fume-function-name-regexp-alist))
+
+;;   ;; Find next forth word in the buffer
+;;   (defun fume-find-next-forth-function-name (buffer)
+;;     "Searches for the next forth word in BUFFER."
+;;     (set-buffer buffer)
+;;     (if (re-search-forward fume-function-name-regexp nil t)
+;;       (let ((beg (match-beginning 2))
+;;             (end (match-end 2)))
+;;         (cons (buffer-substring beg end) beg))))
 
-  (setq fume-find-function-name-method-alist
-  (append '((forth-mode    . fume-find-next-forth-function-name))))
+;;   (setq fume-find-function-name-method-alist
+;;   (append '((forth-mode    . fume-find-next-forth-function-name))))
 
-  ))
+;;   ))
 ;;; End Forth menu
 
 ;;; File folding of forth-files
@@ -1710,43 +1927,44 @@ The region is sent terminated by a newli
 ;;; Works most of the times but loses sync with the cursor occasionally 
 ;;; Could be improved by also folding on comments
 
-(require 'outline)
+;; (dk) This code needs a rewrite; just too ugly and doesn't use the
+;; newer and smarter scanning rules of `imenu'. Who needs it anyway??
 
-(defun f-outline-level ()
-	(cond	((looking-at "\\`\\\\")
-			0)
-		((looking-at "\\\\ SEC")
-			0)
-		((looking-at "\\\\ \\\\ .*")
-			0)
-		((looking-at "\\\\ DEFS")
-			1)
-		((looking-at "\\/\\* ")
-			1)
-		((looking-at ": .*")
-			1)
-		((looking-at "\\\\G")
-			2)
-		((looking-at "[ \t]+\\\\")
-			3))
-)			
-
-(defun fold-f  ()
-   (interactive)
-   (add-hook 'outline-minor-mode-hook 'hide-body)
-
-   ; outline mode header start, i.e. find word definitions
-;;;   (setq  outline-regexp  "^\\(:\\)[ \t]+\\([^ \t]*\\)")
-   (setq  outline-regexp  "\\`\\\\\\|:\\|\\\\ SEC\\|\\\\G\\|[ \t]+\\\\\\|\\\\ DEFS\\|\\/\\*\\|\\\\ \\\\ .*")
-   (setq outline-level 'f-outline-level)
-
-   (outline-minor-mode)
-   (define-key outline-minor-mode-map '(shift up) 'hide-sublevels)
-   (define-key outline-minor-mode-map '(shift right) 'show-children)
-   (define-key outline-minor-mode-map '(shift left) 'hide-subtree)
-   (define-key outline-minor-mode-map '(shift down) 'show-subtree)
+;; (require 'outline)
+
+;; (defun f-outline-level ()
+;;   (cond	((looking-at "\\`\\\\")
+;; 	 0)
+;; 	((looking-at "\\\\ SEC")
+;; 	 0)
+;; 	((looking-at "\\\\ \\\\ .*")
+;; 	 0)
+;; 	((looking-at "\\\\ DEFS")
+;; 	 1)
+;; 	((looking-at "\\/\\* ")
+;; 	 1)
+;; 	((looking-at ": .*")
+;; 	 1)
+;; 	((looking-at "\\\\G")
+;; 	 2)
+;; 	((looking-at "[ \t]+\\\\")
+;; 	 3)))
+  
+;; (defun fold-f  ()
+;;    (interactive)
+;;    (add-hook 'outline-minor-mode-hook 'hide-body)
+
+;;    ; outline mode header start, i.e. find word definitions
+;; ;;;   (setq  outline-regexp  "^\\(:\\)[ \t]+\\([^ \t]*\\)")
+;;    (setq  outline-regexp  "\\`\\\\\\|:\\|\\\\ SEC\\|\\\\G\\|[ \t]+\\\\\\|\\\\ DEFS\\|\\/\\*\\|\\\\ \\\\ .*")
+;;    (setq outline-level 'f-outline-level)
+
+;;    (outline-minor-mode)
+;;    (define-key outline-minor-mode-map '(shift up) 'hide-sublevels)
+;;    (define-key outline-minor-mode-map '(shift right) 'show-children)
+;;    (define-key outline-minor-mode-map '(shift left) 'hide-subtree)
+;;    (define-key outline-minor-mode-map '(shift down) 'show-subtree))
 
-)
 
 ;;(define-key global-map '(shift up) 'fold-f)
 
@@ -1758,13 +1976,14 @@ The region is sent terminated by a newli
 ;;; for all of the recognized languages.  Scanning the buffer takes some time,
 ;;; but not much.
 ;;;
-(cond ((string-match "XEmacs\\|Lucid" emacs-version)
-       (require 'func-menu)
-;;       (define-key global-map 'f8 'function-menu)
-       (add-hook 'find-fible-hooks 'fume-add-menubar-entry)
-;       (define-key global-map "\C-cg" 'fume-prompt-function-goto)
-;       (define-key global-map '(shift button3) 'mouse-function-menu)
-))
+;; (cond ((string-match "XEmacs\\|Lucid" emacs-version)
+;;        (require 'func-menu)
+;; ;;       (define-key global-map 'f8 'function-menu)
+;;        (add-hook 'find-fible-hooks 'fume-add-menubar-entry)
+;; ;       (define-key global-map "\C-cg" 'fume-prompt-function-goto)
+;; ;       (define-key global-map '(shift button3) 'mouse-function-menu)
+;; ))
 
-;;; gforth.el ends here
+(provide 'forth-mode)
 
+;;; gforth.el ends here