(setq inhibit-local-variables t)
(setq shell-file-name "/bin/sh")
(setq load-path (cons (expand-file-name "~/elisp") load-path))
(and
 (boundp 'epoch::version)
 (setq load-path (cons (expand-file-name "~/elisp/epoch") load-path)))
(load "server" 't)
(load "time" 't)
(load "discuss" 't)	; Load discuss, but don't fail if it's not there
(load "shell" 't)	; This tends to get used anyway: load it now
(load "tags" 't)	; ...as does this...
(load "compile" 't)	; ...
(load "dired" 't)	; ...
(load "mh-e" 't)	; ...and this.
(autoload 'c++-mode "c++-mode" "C++ Emacs Mode" 't)

(setq inhibit-startup-message 't)

(defun confirm-exit ()
  "Ask user to confirm exit"
  (interactive)
  (if (yes-or-no-p "Really quit? ")
      (save-buffers-kill-emacs)))

(setq mh-lib "/usr/athena/etc")
(setq mh-progs "/usr/athena/bin")

;; This is for versions of emacs which don't put auto save files in /usr/tmp

(if (not (boundp 'auto-save-main-directory))
    (progn
      (defconst auto-save-main-directory "/usr/tmp/" "auto save dir root")
      (defun make-auto-save-file-name ()
	"Return file name to use for auto-saves of current buffer.
Does not consider auto-save-visited-file-name; that is checked
before calling this function.
You can redefine this for customization.
See also auto-save-file-name-p."
	(if auto-save-main-directory
	    (if buffer-file-name
		(concat auto-save-main-directory
			"#"
			(user-real-uid)
			"."
			(auto-save-replace-slashes buffer-file-name)
			"#")
	      (concat auto-save-main-directory
		      "#%"
		      (user-real-uid)
		      "."
		      (auto-save-replace-slashes (buffer-name))
		      "#"))
	  (if buffer-file-name
	      (concat (file-name-directory buffer-file-name)
		      "#"
		      (file-name-nondirectory buffer-file-name)
		      "#")
	    (expand-file-name (concat "#%" (buffer-name) "#")))))
      (defun auto-save-replace-slashes (name)
	"Replace all slashes in NAME with bangs."
	(let ((pos 0) (len (length name)))
	  (setq ourname (make-string len ? ))
	  (while (< pos len)
	    (if (= (aref name pos) ?/)
		(aset ourname pos ?@)
	      (aset ourname pos (aref name pos)))
	    (setq pos (+ 1 pos)))
	  ourname))))

(setq auto-mode-alist '(
			("\\.c$" . c-mode)
			("\\.h$" . c-mode)
			("\\.i$" . c-mode)
			("\\.mss$" . scribe-mode)
			("\\.s$" . text-mode)
			("\\.tex$" . TeX-mode)
			("\\.el$" . emacs-lisp-mode)
			("\\.text$" . text-mode)
			("\\.gwm$" . lisp-mode)
			("\\.scm$" . scheme-mode)
			("\\.md$" . emacs-lisp-mode)
			("\\.l$" . lisp-mode)
			("\\.lisp$" . lisp-mode)
			("\\.f$" . fortran-mode)
			("/draft$" . draft-mode)
;;; Less common extensions come here
;;; so more common ones above are found faster.
			("\\.TeX$" . TeX-mode)
			("\\.sty$" . LaTeX-mode)
			("\\.bbl$" . LaTeX-mode)
			("\\.bib$" . text-mode)
			("\\.article$" . text-mode)
			("\\.letter$" . text-mode)
			("\\.texinfo$" . texinfo-mode)
			("\\.lsp$" . lisp-mode)
			("\\.y$" . c-mode)
			("\\.cc$" . c-mode)
			("\\.scm.[0-9]*$" . scheme-mode)
			;; .emacs following a directory delimiter
			;; in either Unix or VMS syntax.
			("[]>:/]\\..*emacs" . emacs-lisp-mode)
			("\\.ml$" . lisp-mode)))

;;; Set C-x b to give error if buffer does not exist
(defun switch-to-present-buffer (buffer-name)
  (interactive "BSwitch to buffer : ")
  (cond ((get-buffer buffer-name) (switch-to-buffer buffer-name))
	(t (beep)
	   (princ "Buffer does not exist"))))

;; From epeisach, originally from ???
(defun kill-help-window ()
  "Kill off the stupid help window."
  (interactive)
  (delete-windows-on "*Help*"))

(defun fill-and-indent-paragraph (arg)
  "Fill paragraph and indent rigidly.
Prefix arg sets indent value."
  (interactive "P")
  (save-excursion
    (forward-paragraph)
    (or (bolp) (newline 1))
    (let ((end (point)))
      (backward-paragraph)
      (fill-region-as-paragraph (point) end nil)))
  (save-excursion
    (forward-paragraph)
    (or (bolp) (newline 1))
    (let ((end (point)))
      (backward-paragraph)
      (indent-rigidly (point) end arg))))

(defun format-prog (arg)
  "Indent from point to end of buffer according to the rules of the
current major mode. With arg, indent entire buffer."
 (interactive "P")
 (if arg (goto-line 1))
 (set-mark (point))
 (cond
  ((equal major-mode 'c-mode)
   (c-indent-line)
   (while (equal (forward-line 1) 0)
     (c-indent-line))
   't)
  ((or (equal major-mode 'lisp-mode) (equal major-mode 'emacs-lisp-mode))
   (lisp-indent-line)
   (while (equal (forward-line 1) 0)
     (lisp-indent-line))
   't)
  ;Insert other major mode indent commands here, if you want them.
  (t (beep)
     (princ "Not in a known mode")
     nil)))

(setq require-final-newline 'x)			; Ask before adding newline

(put 'eval-expression 'disabled nil)

(setq default-major-mode 'text-mode)
(setq completion-ignored-extensions
      (append completion-ignored-extensions
              (quote
               (".bak" "~" ".CKP" ".aux" ".otl" ".err"
                       ".lib" ".dvi" ".PS" ".o"))))

; Use Scribe 7
; Assume environment variable HOSTTYPE set (by "setenv HOSTTYPE $hosttype")

(setq scribe-mode-hook
      '(lambda () 
	 (define-key scribe-mode-map "\C-c\C-c" 'scribe)
	 (setq compile-command 
	       (concat "/usr/athena/scribe7 "
		       (buffer-file-name)))))

(setq c-mode-hook
      '(lambda ()
	 (setq case-fold-search nil c-argdecl-indent 0 fill-prefix " * ")
	 ))

(defun show-buffer-file-name ()
  (interactive)
  (princ buffer-file-name))

;;; If on RT, assume using hc compiler.
(if 
    (equal (getenv "HOSTTYPE") "rt") 
    (setq compilation-error-regexp  "\\([^ \n]+\\(: *\\|, line \\|(\\)[0-9]+\\)\\|\\([0-9]+ *of *[^ \n]+\\)\\|\\(\"[^ \n]+\",L[0-9]+\\)"))

;;; Random.  Also doesn't work.  Belongs in mode hook?
(setq fill-column 74)

;;; Bind the function keys to commands. 
(defvar fnkey-map (make-sparse-keymap) "Keymap for function keys")
(define-key esc-map "[" fnkey-map)
(define-key fnkey-map "11~" 'fill-and-indent-paragraph)
(define-key fnkey-map "12~" "    --John Carr (jfc@athena.mit.edu)")
(define-key fnkey-map "13~" 'what-line)
(define-key fnkey-map "14~" 'server-edit)
(define-key fnkey-map "15~" 'compile)
(define-key fnkey-map "17~" 'next-error)
(define-key fnkey-map "18~" 'discuss)
(define-key fnkey-map "19~" 'save-buffer)
(define-key fnkey-map "20~" 'kill-buffer)
(define-key fnkey-map "21~" 'show-buffer-file-name)
(define-key fnkey-map "22~" nil)
(define-key fnkey-map "23~" 'format-prog)
(define-key fnkey-map "24~" 'marc-do-highlight-explicit)
(define-key fnkey-map "5~"  'scroll-up)
(define-key fnkey-map "6~"  'scroll-down)


(define-key fnkey-map "A" 'previous-line)
(define-key fnkey-map "B" 'next-line)
(define-key fnkey-map "D" 'backward-char)
(define-key fnkey-map "C" 'forward-char)
(define-key fnkey-map "P" 'backward-delete-char)	; AIX X

(setq term-type (getenv "TERM"))
(if (or (equal term-type "ibmapa16")	; RT console
	(equal term-type "ibmaed")
	(equal term-type "ibmmono")
	(equal term-type "ibmega"))
    (progn (define-key fnkey-map "Q" 'discuss)
	   (define-key esc-map "A" 'previous-line)
	   (define-key esc-map "B" 'next-line)
	   (define-key esc-map "C" 'forward-char)
	   (define-key esc-map "D" 'backward-char)
	   (define-key esc-map "\C-D" 'kill-word)))

;(if (equal (getenv "TERM") "vt125")
;    (define-key global-map "\C-t" isearch-forward))

(define-key esc-map "g" 'goto-line)
(define-key esc-map "n" 'switch-to-buffer)
(define-key ctl-x-map "b" 'switch-to-present-buffer)
(define-key ctl-x-map "n" nil)	; I pressed C-x n one too many times...
(if (not (boundp 'epoch::version))
    (x-set-bell 'x)		; Use visual bell
  (progn
    (define-key ctl-x-map "\C-c" 'confirm-exit)
    (setq auto-raise-screen nil)
;    (setq target-buffer (get-buffer "*scratch*"))
    (setq epoch::bell-volume 0)
    (modify-syntax-entry ?: "." c-mode-syntax-table)
    (setq epoch::buttons-modify-buffer nil)
    (load "info" 't)
    (load "hyper-man" 't)))

(server-start)
(display-time)

(defun get-local-mail ()
  (interactive)
  (mh-get-new-mail "/usr/spool/mail/jfc"))

(setq mh-folder-mode-hook
      '(lambda ()
	 (define-key mh-folder-mode-map "I" 'get-local-mail)))

(defun draft-mode ()
  "Major mode for editing mail drafts."
  (interactive)
  (text-mode)
  (auto-fill-mode 1))