gforth/gforth.el - diff

Return to gforth.el CVS log

Up to [gforth] / gforth

Diff for /gforth/gforth.el between versions 1.48 and 1.52

version 1.48, 2001/04/08 13:48:11	version 1.52, 2001/06/19 14:49:23
Line 58	Line 58
"List of words for hilighting and recognition of parsed text areas.	"List of words for hilighting and recognition of parsed text areas.
You can enable hilighting of object-oriented Forth code, by appending either	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	`forth-objects-words' or `forth-oof-words' to the list, depending on which
OOP package you're using.	OOP package you're using. After `forth-words' changed, `forth-compile-words'
	must be called to make the changes take effect.

Each item of `forth-words' has the form	Each item of `forth-words' has the form
(MATCHER TYPE HILIGHT . &optional PARSED-TEXT ...)	(MATCHER TYPE HILIGHT . &optional PARSED-TEXT ...)
Line 170 PARSED-TYPE specifies what kind of text	Line 171 PARSED-TYPE specifies what kind of text
immediate (font-lock-constant-face . 3))	immediate (font-lock-constant-face . 3))
))	))

	(defvar forth-use-objects nil
	"*Non-nil makes forth-mode also hilight words from the \"Objects\" package.")
(defvar forth-objects-words nil	(defvar forth-objects-words nil
"Hilighting description for words of the \"Objects\" OOP package")	"Hilighting description for words of the \"Objects\" package")
(setq forth-objects-words	(setq forth-objects-words
'(((":m") definition-starter (font-lock-keyword-face . 1)	'(((":m") definition-starter (font-lock-keyword-face . 1)
"[ \t\n]" t name (font-lock-function-name-face . 3))	"[ \t\n]" t name (font-lock-function-name-face . 3))
Line 201 PARSED-TYPE specifies what kind of text	Line 204 PARSED-TYPE specifies what kind of text
"methods" "end-methods" "this")	"methods" "end-methods" "this")
non-immediate (font-lock-keyword-face . 2))	non-immediate (font-lock-keyword-face . 2))
(("object") non-immediate (font-lock-type-face . 2))))	(("object") non-immediate (font-lock-type-face . 2))))
; (nconc forth-words forth-objects-words)

	(defvar forth-use-oof nil
	"*Non-nil makes forth-mode also hilight words from the \"OOF\" package.")
(defvar forth-oof-words nil	(defvar forth-oof-words nil
"Hilighting description for words of the \"OOF\" OOP package")	"Hilighting description for words of the \"OOF\" package")
(setq forth-oof-words	(setq forth-oof-words
'((("class") non-immediate (font-lock-keyword-face . 2)	'((("class") non-immediate (font-lock-keyword-face . 2)
"[ \t\n]" t name (font-lock-type-face . 3))	"[ \t\n]" t name (font-lock-type-face . 3))
Line 222 PARSED-TYPE specifies what kind of text	Line 226 PARSED-TYPE specifies what kind of text
"endwith")	"endwith")
non-immediate (font-lock-keyword-face . 2))	non-immediate (font-lock-keyword-face . 2))
(("object") non-immediate (font-lock-type-face . 2))))	(("object") non-immediate (font-lock-type-face . 2))))
; (nconc forth-words forth-oof-words)
	(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).")

	(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-hilight-level 3 "*Level of hilighting of Forth code.")

(defvar forth-compiled-words nil "Compiled representation of `forth-words'.")	(defvar forth-compiled-words nil "Compiled representation of `forth-words'.")


; todo:	; todo:
;	;

; Wörter ordentlich hilighten, die nicht auf whitespace beginning ( ..)IF	; Wörter ordentlich hilighten, die nicht auf whitespace beginning ( ..)IF
;	; Additional `forth-use-objects' or
; Buffer-local variables can be set via "Local Variables:" or -*-
; Setting hilighting/indentation specifications requires multi-line variables,
; can only be done in 0 [IF] ... [ENDIF] blocks.
; Additional variable `forth-local-words'/`forth-local-indent-words' required.
; Should be appended to `forth-words'. Additional `forth-use-objects' or
; `forth-use-oof' could be set to non-nil for automatical adding of those	; `forth-use-oof' could be set to non-nil for automatical adding of those
; word-lists.	; word-lists. Using local variable list?
;
; How to use block files with conversion? Use an additional mode? File-ending
; cannot be used for specifying encoding.
; -- Introduce a second mode `forth-blocked-mode', that decodes the buffer
; `decode-coding-region' ands set `buffer-coding-system'. Warning block
; conversion might not work well with regions, since it's a linewise
; conversion
;	;
; Konfiguration über customization groups	; Konfiguration über customization groups
;	;
Line 255 PARSED-TYPE specifies what kind of text	Line 257 PARSED-TYPE specifies what kind of text
; User interface	; User interface
;	;
; 'forth-word' property muss eindeutig sein!	; 'forth-word' property muss eindeutig sein!
	;
	; imenu support schlauer machen

(setq debug-on-error t)	(setq debug-on-error t)

;; Filter list by predicat. This is a somewhat standard function for	;; Filter list by predicate. This is a somewhat standard function for
;; functional programming languages. So why isn't it already implemented	;; functional programming languages. So why isn't it already implemented
;; in Lisp??	;; in Lisp??
(defun forth-filter (predicat list)	(defun forth-filter (predicate list)
(let ((filtered nil))	(let ((filtered nil))
(mapcar (lambda (item)	(mapcar (lambda (item)
(when (funcall predicat item)	(when (funcall predicate item)
(if filtered	(if filtered
(nconc filtered (list item))	(nconc filtered (list item))
(setq filtered (cons item nil))))	(setq filtered (cons item nil))))
Line 296 PARSED-TYPE specifies what kind of text	Line 300 PARSED-TYPE specifies what kind of text
;; parsing of the form	;; parsing of the form
;; (regexp (subexp-count word-description) (subexp-count2 word-description2)	;; (regexp (subexp-count word-description) (subexp-count2 word-description2)
;; ...)	;; ...)
(defun forth-compile-words (words)	(defun forth-compile-wordlist (words)
(let* ((mapped (mapcar 'forth-compile-words-mapper words))	(let* ((mapped (mapcar 'forth-compile-words-mapper words))
(regexp (concat "\\<\\("	(regexp (concat "\\<\\("
(mapconcat 'car mapped "\\\|")	(mapconcat 'car mapped "\\\|")
Line 313 PARSED-TYPE specifies what kind of text	Line 317 PARSED-TYPE specifies what kind of text
(byte-compile 'result)	(byte-compile 'result)
result)))	result)))

	(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
	`forth-compiled-indent-words', respective"
	(setq forth-compiled-words
	(forth-compile-wordlist
	(forth-filter 'forth-words-filter forth-words)))
	(setq forth-compiled-indent-words
	(forth-compile-wordlist forth-indent-words)))

	(defun forth-hack-local-variables ()
	"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	;; get location of first character of previous forth word that's got
;; properties	;; properties
(defun forth-previous-start (pos)	(defun forth-previous-start (pos)
Line 421 PARSED-TYPE specifies what kind of text	Line 458 PARSED-TYPE specifies what kind of text
;; Search for known Forth words in the range `from' to `to', using	;; Search for known Forth words in the range `from' to `to', using
;; `forth-next-known-forth-word' and set their properties via	;; `forth-next-known-forth-word' and set their properties via
;; `forth-set-word-properties'.	;; `forth-set-word-properties'.
(defun forth-update-properties (from to)	(defun forth-update-properties (from to &optional loudly)
(save-excursion	(save-excursion
(let ((msg-flag nil) (state) (word-descr) (last-location))	(let ((msg-count 0) (state) (word-descr) (last-location))
(when (> to (+ from 5000))
(setq msg-flag t) (message "Parsing Forth code..."))
(goto-char (forth-previous-word (forth-previous-start	(goto-char (forth-previous-word (forth-previous-start
(max (point-min) (1- from)))))	(max (point-min) (1- from)))))
(setq to (forth-next-end (min (point-max) (1+ to))))	(setq to (forth-next-end (min (point-max) (1+ to))))
Line 436 PARSED-TYPE specifies what kind of text	Line 471 PARSED-TYPE specifies what kind of text
(forth-delete-properties (point) to)	(forth-delete-properties (point) to)
;; hilight loop...	;; hilight loop...
(while (setq word-descr (forth-next-known-forth-word to))	(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)	(forth-set-word-properties state word-descr)
(when state (put-text-property last-location (point) 'forth-state t))	(when state (put-text-property last-location (point) 'forth-state t))
(let ((type (car word-descr)))	(let ((type (car word-descr)))
Line 452 PARSED-TYPE specifies what kind of text	Line 492 PARSED-TYPE specifies what kind of text
to 'forth-state (current-buffer) (point-max))))	to 'forth-state (current-buffer) (point-max))))
(forth-update-properties to extend-to))	(forth-update-properties to extend-to))
))	))
(when msg-flag (message "Parsing Forth code...done"))
)))	)))

;; save-buffer-state borrowed from `font-lock.el'	;; save-buffer-state borrowed from `font-lock.el'
Line 471 PARSED-TYPE specifies what kind of text	Line 510 PARSED-TYPE specifies what kind of text
;; Function that is added to the `change-functions' hook. Calls	;; Function that is added to the `change-functions' hook. Calls
;; `forth-update-properties' and keeps care of disabling undo information	;; `forth-update-properties' and keeps care of disabling undo information
;; and stuff like that.	;; and stuff like that.
(defun forth-change-function (from to len)	(defun forth-change-function (from to len &optional loudly)
(save-match-data	(save-match-data
(forth-save-buffer-state ()	(forth-save-buffer-state ()
(unwind-protect	(unwind-protect
(progn	(progn
(forth-update-properties from to)	(forth-update-properties from to loudly)
(forth-update-show-screen)	(forth-update-show-screen)
(forth-update-warn-long-lines))))))	(forth-update-warn-long-lines))))))

Line 487 PARSED-TYPE specifies what kind of text	Line 526 PARSED-TYPE specifies what kind of text
(byte-compile 'forth-delete-properties)	(byte-compile 'forth-delete-properties)
(byte-compile 'forth-get-regexp-branch))	(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")


	(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))

	(require 'speedbar)
	(speedbar-add-supported-extension ".fs")
	(speedbar-add-supported-extension ".fb")

;; (require 'profile)	;; (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))	;; (setq profile-functions-list '(forth-set-word-properties forth-next-known-forth-word forth-update-properties forth-delete-properties forth-get-regexp-branch))

Line 525 INDENT1 and INDENT2 are indentation spec	Line 600 INDENT1 and INDENT2 are indentation spec
"[if]" "[ifdef]" "[ifundef]" "[begin]" "[for]" "[do]" "[?do]"	"[if]" "[ifdef]" "[ifundef]" "[begin]" "[for]" "[do]" "[?do]"
"class" "interface" "m:" ":m")	"class" "interface" "m:" ":m")
(0 . 2) (0 . 2))	(0 . 2) (0 . 2))
((";" ";m") (0 . -2) (0 . -2))	((";" ";m") (-2 . 0) (0 . -2))
(("end-code" "again" "repeat" "then" "endtry" "endcase" "endof"	(("end-code" "again" "repeat" "then" "endtry" "endcase" "endof"
"end-struct" "[then]" "[endif]" "[loop]" "[+loop]" "[next]"	"end-struct" "[then]" "[endif]" "[loop]" "[+loop]" "[next]"
"[until]" "[repeat]" "[again]" "end-class" "end-interface"	"[until]" "[repeat]" "[again]" "end-class" "end-interface"
Line 538 INDENT1 and INDENT2 are indentation spec	Line 613 INDENT1 and INDENT2 are indentation spec
(("while" "does>" "[while]") (-1 . 1) (0 . 0))	(("while" "does>" "[while]") (-1 . 1) (0 . 0))
(("\\g") (-2 . 2) (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-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	(defvar forth-indent-level 4
"Indentation of Forth statements.")	"Indentation of Forth statements.")
(defvar forth-minor-indent-level 2	(defvar forth-minor-indent-level 2
Line 627 INDENT1 and INDENT2 are indentation spec	Line 712 INDENT1 and INDENT2 are indentation spec
(column-incr (forth-get-column-incr 0)))	(column-incr (forth-get-column-incr 0)))
(forth-indent-to (if column-incr (+ anchor column-incr) anchor))))	(forth-indent-to (if column-incr (+ anchor column-incr) anchor))))

	(defun forth-current-column ()
	(- (point) (save-excursion (beginning-of-line) (point))))
	(defun forth-current-indentation ()
	(- (save-excursion (beginning-of-line) (forward-to-indentation 0) (point))
	(save-excursion (beginning-of-line) (point))))

(defun forth-indent-to (x)	(defun forth-indent-to (x)
(let ((p nil))	(let ((p nil))
(setq p (- (current-column) (current-indentation)))	(setq p (- (forth-current-column) (forth-current-indentation)))
(forth-delete-indentation)	(forth-delete-indentation)
(beginning-of-line)	(beginning-of-line)
(indent-to x)	(indent-to x)
Line 653 INDENT1 and INDENT2 are indentation spec	Line 744 INDENT1 and INDENT2 are indentation spec

;; insert newline, removing any trailing whitespaces in the current line	;; insert newline, removing any trailing whitespaces in the current line
(defun forth-newline-remove-trailing ()	(defun forth-newline-remove-trailing ()
(newline)
(save-excursion	(save-excursion
(forward-line -1)	(delete-region (point) (progn (skip-chars-backward " \t") (point))))
(forth-remove-trailing)))	(newline))
	; (let ((was-point (point-marker)))
	; (unwind-protect
	; (progn (forward-line -1) (forth-remove-trailing))
	; (goto-char (was-point)))))

;; workaround for bug in `reindent-then-newline-and-indent'	;; workaround for bug in `reindent-then-newline-and-indent'
(defun forth-reindent-then-newline-and-indent ()	(defun forth-reindent-then-newline-and-indent ()
Line 807 screen number."	Line 901 screen number."
(setq overlay-arrow-string forth-overlay-arrow-string)	(setq overlay-arrow-string forth-overlay-arrow-string)
(goto-line first-line)	(goto-line first-line)
(setq overlay-arrow-position forth-screen-marker)	(setq overlay-arrow-position forth-screen-marker)
(when (/= forth-screen-marker (point))	(set-marker forth-screen-marker
(message "Entered screen #%i" scr)	(save-excursion (goto-line first-line) (point)))
(set-marker forth-screen-marker (point)))))))	(setq forth-screen-number-string (format "%d" scr))))))

(add-hook 'forth-motion-hooks 'forth-update-show-screen)	(add-hook 'forth-motion-hooks 'forth-update-show-screen)

Line 898 exceeds 64 characters."	Line 992 exceeds 64 characters."

(defun forth-find-tag (tagname &optional next-p regexp-p)	(defun forth-find-tag (tagname &optional next-p regexp-p)
(interactive (find-tag-interactive "Find tag: "))	(interactive (find-tag-interactive "Find tag: "))
	; (when (not regexp-p)
	; (setq tagname (concat "^\\(" (regexp-opt (list tagname))
	; "\\)$"))
	; (setq regexp-p t))
(switch-to-buffer	(switch-to-buffer
(find-tag-noselect (concat " " tagname " ") next-p regexp-p)))	(find-tag-noselect (concat " " tagname " ") next-p regexp-p)))

Line 944 exceeds 64 characters."	Line 1042 exceeds 64 characters."
(setq comment-indent-hook 'forth-comment-indent)	(setq comment-indent-hook 'forth-comment-indent)
(make-local-variable 'parse-sexp-ignore-comments)	(make-local-variable 'parse-sexp-ignore-comments)
(setq parse-sexp-ignore-comments t)	(setq parse-sexp-ignore-comments t)

(setq case-fold-search t)	(setq case-fold-search t)
(make-local-variable 'forth-words)	(make-local-variable 'forth-words)
(make-local-variable 'forth-compiled-words)	(make-local-variable 'forth-compiled-words)
Line 954 exceeds 64 characters."	Line 1051 exceeds 64 characters."
(make-local-variable 'forth-show-screen)	(make-local-variable 'forth-show-screen)
(make-local-variable 'forth-screen-marker)	(make-local-variable 'forth-screen-marker)
(make-local-variable 'forth-warn-long-lines)	(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))	(setq forth-screen-marker (copy-marker 0))
)	(add-hook 'after-change-functions 'forth-change-function)
	(setq imenu-create-index-function 'forth-create-index))

(defun forth-mode-hook-dependent-variables ()
(setq forth-compiled-words
(forth-compile-words (forth-filter 'forth-words-filter forth-words)))
(setq forth-compiled-indent-words
(forth-compile-words forth-indent-words)))

;;;###autoload	;;;###autoload
(defun forth-mode ()	(defun forth-mode ()
"	"
Major mode for editing Forth code. Tab indents for Forth code. Comments	Major mode for editing Forth code. Tab indents for Forth code. Comments
are delimited with \\ and newline. Paragraphs are separated by blank lines	are delimited with \\ and newline. Paragraphs are separated by blank lines
only. Block files are autodetected, when read, and converted to normal stream	only. Block files are autodetected, when read, and converted to normal
source format. See also `forth-block-mode'.	stream source format. See also `forth-block-mode'.
\\{forth-mode-map}	\\{forth-mode-map}
Forth-split	Forth-split
Positions the current buffer on top and a forth-interaction window	Positions the current buffer on top and a forth-interaction window
Line 1000 Variables controlling interaction and st	Line 1095 Variables controlling interaction and st
Variables controlling syntax hilighting/recognition of parsed text:	Variables controlling syntax hilighting/recognition of parsed text:
`forth-words'	`forth-words'
List of words that have a special parsing behaviour and/or should be	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
forth-objects-words	.emacs, or by setting forth-local-words, in source-files' local
Hilighting information for the words of the \"Objects\" package for	variables lists.
object-oriented programming. Append it to `forth-words', if required.	forth-use-objects
forth-oof-words	Set this variable to non-nil in your .emacs, or a local variables
Hilighting information for the words of the \"OOF\" package.	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
	a local variables list at the end of file, to get file-specific
	hilighting.
	0 [IF]
	Local Variables: ...
	forth-local-words: ...
	End:
	[THEN]
forth-hilight-level	forth-hilight-level
Controls how much syntax hilighting is done. Should be in the range	Controls how much syntax hilighting is done. Should be in the range
0 (no hilighting) up to 3.	0..3

Variables controlling indentation style:	Variables controlling indentation style:
`forth-indent-words'	`forth-indent-words'
List of words that influence indentation.	List of words that influence indentation.
	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
	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	forth-indent-level
Indentation increment/decrement of Forth statements.	Indentation increment/decrement of Forth statements.
forth-minor-indent-level	forth-minor-indent-level
Minor indentation increment/decrement of Forth statemens.	Minor indentation increment/decrement of Forth statemens.

Variables controlling block-file editing:	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	Non-nil means, that the start of the current screen is marked by an
overlay arrow, and motion over screen boundaries displays the number	overlay arrow, and screen numbers are displayed in the mode line.
of the screen entered. This variable is by default nil for `forth-mode'	This variable is by default nil for `forth-mode' and t for
and t for `forth-block-mode'.	`forth-block-mode'.
`forth-overlay-arrow-string'	forth-overlay-arrow-string
String to display as the overlay arrow, when `forth-show-screen' is t.	String to display as the overlay arrow, when `forth-show-screen' is t.
Setting this variable to nil disables the overlay arrow.	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.	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	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	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	length that can be stored into a block file). This variable defaults to
Line 1064 Variables controling documentation searc	Line 1182 Variables controling documentation searc
(forth-mode-variables)	(forth-mode-variables)
; (if (not (forth-process-running-p))	; (if (not (forth-process-running-p))
; (run-forth forth-program-name))	; (run-forth forth-program-name))
(run-hooks 'forth-mode-hook)	(run-hooks 'forth-mode-hook))
(forth-mode-hook-dependent-variables)
(forth-change-function (point-min) (point-max) nil)
(add-hook 'after-change-functions 'forth-change-function))

	;;;###autoload
(define-derived-mode forth-block-mode forth-mode "Forth Block Source"	(define-derived-mode forth-block-mode forth-mode "Forth Block Source"
"Major mode for editing Forth block source files, derived from	"Major mode for editing Forth block source files, derived from
`forth-mode'. Differences to `forth-mode' are:	`forth-mode'. Differences to `forth-mode' are:
Line 1082 echo area and the line is truncated.	Line 1198 echo area and the line is truncated.

Another problem is imposed by block files that contain newline or tab	Another problem is imposed by block files that contain newline or tab
characters. When Emacs converts such files back to block file format,	characters. When Emacs converts such files back to block file format,
it'll translate those characters to a number of spaces. However, whenever	it'll translate those characters to a number of spaces. However, when
you read such a file, a warning message is displayed in the echo area,	you read such a file, a warning message is displayed in the echo area,
including a line number that may help you to locate and fix the problem.	including a line number that may help you to locate and fix the problem.

Line 1090 So have a look at the Messages buffer,	Line 1206 So have a look at the Messages buffer,
bell during block file read/write operations."	bell during block file read/write operations."
(setq buffer-file-format '(forth-blocks))	(setq buffer-file-format '(forth-blocks))
(setq forth-show-screen t)	(setq forth-show-screen t)
(setq forth-warn-long-lines t))	(setq forth-warn-long-lines t)
	(setq forth-screen-number-string (format "%d" forth-block-base))
	(setq mode-line-format (append (reverse (cdr (reverse mode-line-format)))
	'("--S" forth-screen-number-string "-%-"))))

(add-hook 'forth-mode-hook	(add-hook 'forth-mode-hook
'(lambda ()	'(lambda ()
(make-local-variable 'compile-command)	(make-local-variable 'compile-command)
(setq compile-command "gforth ")))	(setq compile-command "gforth ")
	(forth-hack-local-variables)
	(forth-customize-words)
	(forth-compile-words)
	(forth-change-function (point-min) (point-max) nil t)))

(defun forth-fill-paragraph ()	(defun forth-fill-paragraph ()
"Fill comments (starting with '\'; do not fill code (block style	"Fill comments (starting with '\'; do not fill code (block style
Line 1726 The region is sent terminated by a newli	Line 1849 The region is sent terminated by a newli
))	))

;;; gforth.el ends here	;;; gforth.el ends here

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>

Removed from v.1.48
changed lines
	Added in v.1.52