LISTING FOR  >spec>install>1136>emacs-object-mode
COMPILED BY Multics LISP Compiler, Version 2.13c, July 11, 1983
ON 08/20/86  2251.3 mst Wed
IN BEHALF OF Martinson.SysMaint.a



;;; ***********************************************************
;;; *                                                         *
;;; * Copyright, (C) Honeywell Information Systems Inc., 1982 *
;;; *                                                         *
;;; * Copyright (c) 1978 by Massachusetts Institute of        *
;;; * Technology and Honeywell Information Systems, Inc.      *
;;; *                                                         *
;;; ***********************************************************

;;;
;;;
;;; Emacs Object Mode, because it was necessary.


;;; HISTORY COMMENTS:
;;;  1) change(81-05-05,Soley), approve(), audit(),
;;;     install(86-08-20,MR12.0-1136):
;;;     pre-hcom history:
;;;     Originally written.
;;;  2) change(86-02-24,Margolin), approve(86-02-24,MCR7325),
;;;     audit(86-08-12,Harvey), install(86-08-20,MR12.0-1136):
;;;     Converted to use the new e_multics_files_ primitives.  Changed the #
;;;     read-macro to the more standard #o macro.  Changed lsh/boole
;;;     combinations into ldb.
;;;                                                      END HISTORY COMMENTS

;;;

(%include e-macros)
(%include emacs-internal-macros)
(%include defun)
(%include other_other)
(%include sharpsign)
(%include runtime)
(eval-when (eval compile load) (sstatus feature runtime))	; write-around bug

(declare (special object-mode-count object-mode-chars last-input-char
	        known-buflist NL object-mode-total)
         (*lexpr absolute-pathname close-file open-file)
         (*expr check-minibuffer-file-command
	      open-star-name-single))

;;; Returns octal string representation, padded on the left with 0.

(defun pad-left-octal (number)
       (let ((rep (octal-rep number)))
	  (cond ((= (stringlength rep) 3) rep)
	        ((= (stringlength rep) 2) (catenate "0" rep))
	        ('else (catenate "00" rep)))))

(defun pad-left-6octal (number)
       (let ((rep (octal-rep number)))
	  (catenate (substr "000000" 1 (- 6. (stringlength rep)))
		  rep)))

;;; Returns octal string representation.

(defun octal-rep (x)
       (let ((base 8.) (*nopoint t))
	  (maknam (explodec x))))

;;; This is the end-of-file-function for object-mode-read-file.

(defun object-mode-eoffn (a b) a b (throw 'done object-mode-tag))

;;; This functions reads in a file, inserting the object in object-mode
;;; format into the current buffer.  Doesn't check pathname at all.

(defun object-mode-read-file (pathname)
       (let ((read-only-flag nil))
	  (destroy-buffer-contents)
	  (setq object-mode-count 0 object-mode-chars ()
	        fpathname (e_lap_$rtrim pathname) object-mode-total 0)
	  (let ((fo (open pathname '(in ascii fixnum))))
	       (eoffn fo 'object-mode-eoffn)
	       (minibuffer-remark "Reading...")
	       (catch
	         (do () (()) (object-mode-read-word fo))
	         object-mode-tag)
	       (close fo))
	  (or (zerop object-mode-count) (object-mode-finish-line))
	  (go-to-beginning-of-buffer)
	  (setq buffer-modified-flag nil)))

;;; Function to read in one word from the input file and update
;;; the current line with that information.

(defun object-mode-read-word (file)
       (let ((word (in file)))
	  (setq object-mode-count (1+ object-mode-count))
	  (let ((c1 (ldb #o3311 word))
	        (c2 (ldb #o2211 word))
	        (c3 (ldb #o1111 word))
	        (c4 (ldb #o0011 word)))
	       (setq object-mode-chars
		   (list* c4 c3 c2 c1 object-mode-chars))
	       (insert-string
	         (catenate (pad-left-octal c1) " "
		         (pad-left-octal c2) " "
		         (pad-left-octal c3) " "
		         (pad-left-octal c4) "   "))))
       (and (= object-mode-count 3) (object-mode-finish-line)))

;;; Finish off a line of object.

(defun object-mode-finish-line ()
       (save-excursion
         (go-to-beginning-of-line)
         (insert-string (pad-left-6octal object-mode-total))
         (insert-string "   "))
       (setq object-mode-total (+ object-mode-total 3))
       (or (= object-mode-count 3)
	 (do n object-mode-count (1+ n) (> n 2)
	     (insert-string "                  ")))
       (setq object-mode-count 0)
       (do ((n 0 (1+ n))
	  (chars (nreverse object-mode-chars) (cdr chars)))
	 ((or (null chars) (= n 12.)))
	 (and (zerop (\ n 4)) (insert-string " "))
	 (let ((this (car chars)))
	      (object-mode-insert-letter this)))
       (setq object-mode-chars ())
       (new-line))

;;; To write an object file.  Real work done below: this just insures
;;; access, etc.

(defun object-mode-write-file (file-name &aux (file-object nil))
       (protect
         (setq file-object (open-file file-name 'write-force))
         (object-mode-write (absolute-pathname (fobj-path file-object)))
         &always
         ;;restore access, bit-count set by "close" below
         ;; this kludge necessary because "close" may also
         ;; terminate the segment
         (let ((new-fo (open-file file-name 'write nil)))
	    (when new-fo
		(setf (fobj-original-access new-fo)	;copy access restoration info
		      (fobj-original-access file-object))    ;to useful file object
		(close-file new-fo nil)	;restore access
		(setf (fobj-original-access file-object) nil)))
         (close-file file-object nil)))		;clean up FCB

;;; Function to output an object-code buffer.  Besides the side
;;; effect of writing out the buffer, returns 4 times the amount
;;; of words in the file.

(defun object-mode-write (file)
       (save-excursion
         (let ((fo (open file '(out ascii fixnum))))
	    (go-to-beginning-of-buffer)
	    (setq object-mode-count 0)
	    (minibuffer-remark "Writing...")
	    (let ((total-words 1))
	         (catch
		 (do () (())
		     (object-mode-write-word fo)
		     (setq total-words (1+ total-words)))
		 object-mode-tag)
	         (setq buffer-modified-flag nil 
		     fpathname (e_lap_$rtrim file))
	         (minibuffer-remark "Written.")
	         (close fo)
	         (* 4. total-words)))))

;;; Reads the octal word at the point in the buffer, and moves
;;; forward to the next group.

(defun object-mode-get-octal ()
       (with-mark beginning-of-word
	        (forward-word)
	        (prog1 (readlist
		       (exploden
		         (point-mark-to-string beginning-of-word)))
		     (forward-char))))

;;; Function to output a single word of a file, given that we
;;; are at the beginning of the representation of that word
;;; in the buffer.

(defun object-mode-write-word (file)
       (and (zerop (cur-hpos)) (go-to-hpos 9.))
       (out file
	  (+ (lsh (object-mode-get-octal) 27.)
	     (lsh (object-mode-get-octal) 18.)
	     (lsh (object-mode-get-octal) 9.)
	     (object-mode-get-octal)))
       (forward-char) (forward-char)
       (setq object-mode-count (1+ object-mode-count))
       (cond ((= 3 object-mode-count)
	    (setq object-mode-count 0)
	    (next-line)))
       (cond ((or (line-is-blank) (eolp) (looking-at " "))
	    (throw 'done object-mode-tag))))

;;; Insert letter in letters column.

(defun object-mode-insert-letter (number)
       (cond ((and (> number #o37) (< number #o177))
	    (insert-char (ItoC number)))
	   ('else (insert-char "."))))

;;; Give an error message stipulating that we're in
;;; a non-editable column.

(defun object-mode-bad-column ()
       (display-error "Nothing to edit in this column."))

;;; Decides what type of column we are currently in:
;;; 'numbers => the numeric kind of column.
;;; 'letters => the alphabetic kind of column.
;;; If in a bad column type, gives an error message.

(defun object-mode-column-type ()
       (let ((h (cur-hpos)))
	  (cond ((< h 9.) (object-mode-bad-column))
	        ((or (> h 77.) (eolp)) (object-mode-bad-column))
	        ((> h 63.)
	         (cond ((member h '(68. 73.)) (object-mode-bad-column))
		     ('else 'letters)))
	        ((eq (curchar) '/ ) (object-mode-bad-column))
	        ('else 'numbers))))

;;; Given that we are IN a numeric column, this updates this
;;; group of numbers AND the associated ascii to the right.  We
;;; assume that the new number has been inserted already.

(defun object-mode-update-number ()
       (save-excursion
         (forward-char)
         (backward-word)
         (let ((h (- (cur-hpos) 9.))
	     (number (with-mark beginning-of-word
			    (forward-word)
			    (readlist
			      (exploden
			        (point-mark-to-string
				beginning-of-word))))))
	    (go-to-hpos (+ 64.
		         (* (// h 18.) 5.)
		         (// (\ h 18.) 4.)))
	    (delete-char)
	    (object-mode-insert-letter number))))

;;; Given that we are IN a letter column, this updates this
;;; letter AND the associated numbers to the right.  We
;;; assume that the new letter has been inserted already.

(defun object-mode-update-letter ()
       (save-excursion
         (let ((h (- (cur-hpos) 64.))
	     (number (CtoI (curchar))))
	    (delete-char)
	    (object-mode-insert-letter number)
	    (go-to-hpos (+ 9. (* 18. (// h 5.)) (* 4. (\ h 5))))
	    (delete-word)
	    (insert-string (pad-left-octal number)))))

;;; Replacement for self-insert.

(defun object-mode-self-insert ()
       (cond ((eq (object-mode-column-type) 'letters)
	    (let ((read-only-flag nil))
	         (delete-char)
	         (insert-char last-input-char)
	         (backward-char)
	         (object-mode-update-letter)))
	   ((member last-input-char '(/0 /1 /2 /3 /4 /5 /6 /7))
	    (let ((read-only-flag nil))
	         (delete-char)
	         (insert-char last-input-char)
	         (backward-char)
	         (object-mode-update-number)))
	   ('else
	     (display-error
	       "You may only enter an octal number in this column.")))
       (object-mode-forward-char))

;;; Replacement for quote-char.

(defun object-mode-quote-char ()
       (let ((last-input-char (make_atom (ItoC (get-char)))))
	  (object-mode-self-insert)))

;;; Save-same-file for object mode.

(defcom object-mode-save-same-file
        (check-minibuffer-file-command)
        (or fpathname
	  (display-error "No default pathname for this buffer."))
        (object-mode-write-file fpathname))

;;; write-file for object mode.

(defcom object-mode-write-buffer
        &args ((file &prompt "Write Object File: "
		 &default &eval
		 (or fpathname
		     (display-error
		       "No default pathname for this buffer."))))
        (check-minibuffer-file-command)
        (or file
	  (display-error "No default pathname for this buffer."))
        (object-mode-write-file file))

;;; Command to read a file in in object mode.

(defcom object-mode-find-file
        &args ((name &prompt "Find Object File: "
		 &default &eval
		 (display-error "You must supply a pathname.")))
        (let ((in (open-star-name-single name 'read))) ;Check existence/access
	   (close-file in nil)
	   (setq name (fobj-path in))
	   (unless (nullstringp (pn-component name))
		 (report-error 'error_table_$archive_pathname))
	   (go-to-or-create-buffer
	     (object-mode-pick-buffer (pn-entry name)))
	   (object-mode-read-file (absolute-pathname name))
	   (object-mode)))
	   
;;; Pick a good buffer to go to.

(defun object-mode-pick-buffer (buffer)
       (cond ((memq (make_atom buffer) known-buflist)
	    (ring-tty-bell)
	    (object-mode-pick-buffer
	      (minibuf-response
	        (catenate "Buffer " buffer
		        " is already in use.  New buffer: ")
	        NL)))
	   ('else (make_atom buffer))))

;;; Same as read-file for object-mode.  When using this,
;;; we can assume you are in an object-mode buffer.

(defcom object-mode-read-command
        &prologue &eval (or (eq current-buffer-mode 'Object)
		        (display-error "You must be in Object mode."))
        &args ((name &prompt "Read Object File: "
		 &default
		 &eval (or fpathname
			 (display-error
			   "No default pathname for this buffer."))))
        (let ((in (open-star-name-single name 'read)))
	   (close-file in nil)
	   (setq name (fobj-path in))
	   (unless (nullstringp (pn-component name))
		 (report-error 'error_table_$archive_pathname))
	   (object-mode-read-file (absolute-pathname name))))

;;; Go forward one character in an interesting way.

(defcom object-mode-forward-char
        (forward-char)
        (let ((h (cur-hpos)))
	   (cond ((< h 60.) (skip-over-whitespace-in-line))
	         ((= h 60.) (next-line) (go-to-hpos 9.))
	         ((member h '(68. 73.)) (forward-char))
	         ((eolp) (next-line) (go-to-hpos 64.)))))

;;; Instate object mode.

(defun object-mode ()
       (setq current-buffer-mode 'Object)
       (setq read-only-flag 't)
       (map-over-emacs-commands
	'(lambda (symbol function junk) junk
	         (and (eq function 'self-insert)
		    (set-key symbol 'object-mode-self-insert)))
	())
       (set-key "^M"    'object-mode-self-insert)
       (set-key "^Q"    'object-mode-quote-char)
       (set-key "^X-^S" 'object-mode-save-same-file)
       (set-key "^X-^W" 'object-mode-write-buffer)
       (set-key "^X-^R" 'object-mode-read-command))

INCLUDE FILE >spec>install>1136>executable>e-macros.incl.lisp

;;; BEGIN INCLUDE FILE e-macros.incl.lisp

;;; Declares for use by Emacs programs and extenstions.  Also loads
;;; in e_macros_, which contains macro definitions.

;;; HISTORY COMMENTS:
;;;  1) change(85-01-01,Margolin), approve(86-02-24,MCR7186),
;;;     audit(86-08-12,Harvey), install(86-08-20,MR12.0-1136):
;;;     Written: New Year's Day 1985, by excerpting the old e-macros.incl.lisp
;;;     and leaving out all the definitions and qwerty junk (don't ask).
;;;  2) change(86-02-24,Margolin), approve(86-02-24,MCR7325),
;;;     audit(86-08-12,Harvey), install(86-08-20,MR12.0-1136):
;;;     Alphabetized declarations, and added more declarations for documented
;;;     functions, and also for some undocumented functions.
;;;                                                      END HISTORY COMMENTS

(%include backquote)

(declare					;basic editor stuff
  (*expr apply-catenate
         assert-minor-mode backward-char backward-n-chars charlisten
         charset-member command-abort command-quit
         copy-region cur-hpos curline-as-string curbuf-as-string curchar
         curline-as-string delete-char delete-word destroy-buffer-contents
         dont-notice-modified-buffer e_cline_ e_lap_$reverse-search-string
         e_lap_$trim empty-buffer-p error_table_ establish-local-var
         exchange-point-and-mark firstlinep forward-char forward-n-chars
         forward-regexp-search-in-line forward-search forward-search-in-line
         get-char get-search-string go-to-beginning-of-buffer
         go-to-beginning-of-line go-to-buffer go-to-end-of-buffer
         go-to-end-of-line go-to-hpos go-to-mark go-to-or-create-buffer
         insert-char insert-string kill-backwards-to-mark kill-forward-to-mark
         kill-pop kill-to-end-of-line killsave-string lastlinep loadfile
         looking-at lowercase map-over-emacs-commands mark-on-current-line-p
         mark-reached merge-kills-forward merge-kills-reverse move-mark
         minibuf-response minibuffer-clear
         negate-minor-mode new-line next-line nullstringp pathname_
         pathname_$component point-mark-to-string
         point>markp prev-line printable process-char produce-named-mark-list
         read-in-file release-mark reverse-search
         register-local-var reverse-search-in-line
         search-back-first-charset-line
         search-back-first-not-charset-line search-failure-annunciator
         search-for-first-charset-line search-for-first-not-charset-line
         set-emacs-epilogue-handler set-buffer-self-destruct set-key
         set-mark-here set-mark set-perm-key set-the-mark set-the-mark-here
         skip-to-whitespace skip-to-whitespace-in-line
         wipe-point-mark wipe-region write-out-file
         trim-minibuf-response yesp yank)
  (*fexpr define-autoload-lib))

(declare					;redisplay stuff
  (*expr end-local-displays init-local-displays ring-tty-bell
         local-display-generator local-display-generator-nnl
         next-screen prev-screen local-display-current-line
         find-buffer-in-window select-buffer-window window-info
         select-buffer-find-window select-other-window select-window
         buffer-on-display-in-window redisplay full-redisplay))

(declare					;extended stuff
  (*expr forward-word backward-word skip-over-whitespace skip-back-whitespace
         skip-over-whitespace-in-line skip-back-whitespace-in-line
         skip-back-to-whitespace skip-to-whitespace rubout-char date
         display-buffer-as-printout delete-white-sides lefthand-char
         format-to-col whitespace-to-hpos line-is-blank decimal-rep
         register-option minibuffer-clear))

(declare (*lexpr display-error display-com-error display-error-noabort
	       display-error-remark comout-get-output
	       display-com-error-noabort minibuffer-print
	       minibuffer-response trim-minibuffer-response
	       intern-minibuffer-response minibuffer-remark
	       minibuffer-print-noclear report-error report-error-noabort))

(declare (special TAB NL SPACE ESC curpointpos current-buffer dont-stash
	        numarg der-wahrer-mark fpathname fill-column completion-list
	        curlinel BACKSPACE read-only-flag buffer-modified-flag
	        previous-buffer current-buffer-mode env-dir process-dir
	        minibuffer-end-string NLCHARSTRING undo null-pointer))

;;; Load in macro packages
(eval-when (eval compile)
  (or (status feature e-defcom)
      (progn (load (catenate (car (namelist (truename infile))) ">e_define_command_"))
	   (sstatus feature e-defcom)))
  (or (status feature e-macros)
      (load (catenate (car (namelist (truename infile))) ">e_macros_"))))

;;; END INCLUDE FILE e-macros.incl.lisp

INCLUDE FILE >ldd>include>backquote.incl.lisp

;;;
;;; backquote.incl.lisp - BSG 10/9/79
;;; Loads lisp_backquote_ into either the compiler or interpreter
;;; environment.
;;;
;;; Modified 10/30/82 by Richard Lamson to use eval-when and
;;;				   (status feature backquote)
;;;
(eval-when (eval compile)
  (or (status feature backquote)
      (load (catenate (car (namelist (truename infile))) ">lisp_backquote_"))))

INCLUDE FILE >spec>install>1136>executable>emacs-internal-macros.incl.lisp

;;; BEGIN INCLUDE FILE emacs-internal-macros.incl.lisp

;;; Loads in e_internal_macros_

;;; HISTORY COMMENTS:
;;;  1) change(85-01-06,Margolin), approve(86-02-24,MCR7186),
;;;     audit(86-08-20,Harvey), install(86-08-20,MR12.0-1136):
;;;     Created.
;;;                                                      END HISTORY COMMENTS

(%include defstruct)
(%include setf)

(eval-when (compile eval)
  (or (status feature e-internal-macros)
      (load (catenate (car (namelist (truename infile)))
		  ">e_internal_macros_")))
  (sstatus feature e-internal-macros))

(declare
  (*expr e$get_temporary_seg e$release_temporary_seg
         e_lap_$ggcharn e_lap_$gsubstr e_lap_$return-string e_lap_$rtrim
         e_lap_$segnlindex e_lap_$write-string
         exists-buffer get-buffer-state map-over-emacs-buffers
         order-mark-last))

(declare
  (special buffer-file-dtcm		;DTCM of the file associated with the current buffer
	 buffer-tempsegs		;list of temp segs for current buffer
	 buffer-uid		;Multics UID of segment this buffer is "eq" to
				;for arch. comp, (UID . compname)
	 curline			;current line
	 curlinel			;length of current line
	 curpointpos		;# of chars to left of cursor on line
	 curstuff			;the current line (string or filecons)
	 firstline		;first line of buffer
	 known-buflist		;list of defined buffers
	 lastline			;last line of current buffer
	 minibufferp		;non-nil if in minibuffer
	 tty-no-upmotionp		;non-display terminal
	 work-string		;black-magic string containing open line
	 ))

;;; END INCLUDE FILE emacs-internal-macros.incl.lisp

INCLUDE FILE >ldd>include>defstruct.incl.lisp

;; -*- Mode: Lisp; Lowercase: True -*-

;; defstruct.incl.lisp - Loads lisp_defstruct_ and lisp_setf_ into either the
;; compiler or interpreter environment.
;; Written:	October 1982 by Alan Bawden, Carl Hoffman, and Rich Lamson

(eval-when (eval compile)
  (or (status feature setf)
      (load (catenate (car (namelist (truename infile))) ">lisp_setf_")))
  (or (status feature defstruct)
      (load (catenate (car (namelist (truename infile))) ">lisp_defstruct_"))))

INCLUDE FILE >ldd>include>setf.incl.lisp

;; -*- Mode: Lisp; Lowercase: True -*-

;; setf.incl.lisp - Loads lisp_setf_ into either the compiler or
;; interpreter environment.
;; Written:  October 1982 by Carl Hoffman

(eval-when (eval compile)
  (or (status feature setf)
      (load (catenate (car (namelist (truename infile))) ">lisp_setf_"))))

INCLUDE FILE >ldd>include>defun.incl.lisp

;; -*- Mode: Lisp; Lowercase: True -*-

;; defun.incl.lisp - Loads lisp_destructuring_let_, lisp_defmacro_,
;; and lisp_defun_ into either the compiler or interpreter environment.
;; Written:  October 1982 by Carl Hoffman

;; defun needs destructuring_let and defmacro to run.  The code produced contains
;; let forms, and an internal routine in defmacro is called.

(eval-when (eval compile)
  (or (status feature destructuring_let)
      (load (catenate (car (namelist (truename infile))) ">lisp_destructuring_let_")))
  (or (status feature defmacro)
      (load (catenate (car (namelist (truename infile))) ">lisp_defmacro_")))
  (or (status feature defun)
      (load (catenate (car (namelist (truename infile))) ">lisp_defun_"))))

INCLUDE FILE >ldd>include>other_other.incl.lisp

;; -*- Mode: Lisp; Lowercase: True -*-

;; other_other.incl.lisp - Loads lisp_setf_ and lisp_other_other_ into either
;; the compiler or interpreter environment.
;; Written:  October 1982 by Carl Hoffman

(eval-when (eval compile)
  (or (status feature setf)
      (load (catenate (car (namelist (truename infile))) ">lisp_setf_")))
  (or (status feature other_other)
      (load (catenate (car (namelist (truename infile))) ">lisp_other_other_"))))

INCLUDE FILE >ldd>include>sharpsign.incl.lisp

;; -*- Mode: Lisp; Lowercase: True -*-

;; sharpsign.incl.lisp - Loads lisp_sharpsign_ into either the compiler or
;; interpreter environment.
;; Written:  October 1982 by Carl Hoffman

(eval-when (eval compile)
  (or (status feature sharpsign)
      (load (catenate (car (namelist (truename infile))) ">lisp_sharpsign_"))))

INCLUDE FILE >ldd>include>runtime.incl.lisp

;; -*- Mode: Lisp; Lowercase: True -*-

;; runtime.incl.lisp - Loads lisp_runtime_ into the interpreter environment.
;; Written:  October 1982 by Carl Hoffman

(eval-when (eval compile)
  (defun --load-myself-- macro (module)
    (setq module (cadr module))
    (list 'or
	(list 'status 'feature module)
	(list 'load (catenate (car (namelist (truename infile)))
			  ">lisp_" module "_")))))

(--load-myself-- runtime)

(declare (*expr fboundp fmakunbound fsymeval fset
	      ldb dpb
	      firstn butlast nbutlast
	      mem find-position-in-list ass rassq rassoc
	      circular-list-last)
         (*lexpr make-list rem remq remove symbolconc del))

			Functions Defined

Name			Offset		Offset		Name


object-mode                      2120		   0		pad-left-octal
object-mode-bad-column           1156		   44		pad-left-6octal
object-mode-column-type          1164		   77		octal-rep
object-mode-eoffn                116		   116		object-mode-eoffn
object-mode-find-file            1616		   123		object-mode-read-file
object-mode-find-file-$-1-$-&default    1675		   226		object-mode-read-word
object-mode-finish-line          366		   366		object-mode-finish-line
object-mode-forward-char         2044		   532		object-mode-write-file
object-mode-get-octal            772		   646		object-mode-write
object-mode-insert-letter        1134		   772		object-mode-get-octal
object-mode-pick-buffer          1703		   1030		object-mode-write-word
object-mode-quote-char           1531		   1134		object-mode-insert-letter
object-mode-read-command         1751		   1156		object-mode-bad-column
object-mode-read-command-$-0-$-&prologue    2020		   1164		object-mode-column-type
object-mode-read-command-$-1-$-&default    2033		   1233		object-mode-update-number
object-mode-read-file            123		   1355		object-mode-update-letter
object-mode-read-word            226		   1456		object-mode-self-insert
object-mode-save-same-file       1550		   1531		object-mode-quote-char
object-mode-self-insert          1456		   1550		object-mode-save-same-file
object-mode-update-letter        1355		   1566		object-mode-write-buffer
object-mode-update-number        1233		   1605		object-mode-write-buffer-$-1-$-&default
object-mode-write                646		   1616		object-mode-find-file
object-mode-write-buffer         1566		   1675		object-mode-find-file-$-1-$-&default
object-mode-write-buffer-$-1-$-&default    1605		   1703		object-mode-pick-buffer
object-mode-write-file           532		   1751		object-mode-read-command
object-mode-write-word           1030		   2020		object-mode-read-command-$-0-$-&prologue
octal-rep                        77		   2033		object-mode-read-command-$-1-$-&default
pad-left-6octal                  44		   2044		object-mode-forward-char
pad-left-octal                   0		   2120		object-mode





			Functions Referenced

CtoI                                    go-to-mark                              object-mode-read-file
ItoC                                    go-to-or-create-buffer                  object-mode-read-word
absolute-pathname                       in                                      object-mode-self-insert
backward-char                           insert-char                             object-mode-update-letter
backward-word                           insert-string                           object-mode-update-number
catenate                                ldb                                     object-mode-write
catenate                                line-is-blank                           object-mode-write-file
catenate                                looking-at                              object-mode-write-word
check-minibuffer-file-command           make_atom                               octal-rep
close                                   maknam                                  open
close-file                              map-over-emacs-commands                 open-file
cur-hpos                                member                                  open-file
curchar                                 minibuf-response                        open-star-name-single
delete-char                             minibuffer-remark                       out
delete-word                             new-line                                pad-left-6octal
destroy-buffer-contents                 next-line                               pad-left-octal
display-error                           nreverse                                point-mark-to-string
e_lap_$rtrim                            nullstringp                             readlist
eoffn                                   object-mode                             release-mark
explodec                                object-mode-bad-column                  report-error
exploden                                object-mode-column-type                 ring-tty-bell
forward-char                            object-mode-finish-line                 set-key
forward-word                            object-mode-forward-char                set-mark
get-char                                object-mode-get-octal                   skip-over-whitespace-in-line
go-to-beginning-of-buffer               object-mode-insert-letter               stringlength
go-to-beginning-of-line                 object-mode-pick-buffer                 substr
go-to-hpos                                                                      


                                          -----------------------------------------------------------


Historical Background

This edition of the Multics software materials and documentation is provided and donated
to Massachusetts Institute of Technology by Group BULL including BULL HN Information Systems Inc. 
as a contribution to computer science knowledge.  
This donation is made also to give evidence of the common contributions of Massachusetts Institute of Technology,
Bell Laboratories, General Electric, Honeywell Information Systems Inc., Honeywell BULL Inc., Groupe BULL
and BULL HN Information Systems Inc. to the development of this operating system. 
Multics development was initiated by Massachusetts Institute of Technology Project MAC (1963-1970),
renamed the MIT Laboratory for Computer Science and Artificial Intelligence in the mid 1970s, under the leadership
of Professor Fernando Jose Corbato. Users consider that Multics provided the best software architecture 
for managing computer hardware properly and for executing programs. Many subsequent operating systems 
incorporated Multics principles.
Multics was distributed in 1975 to 2000 by Group Bull in Europe , and in the U.S. by Bull HN Information Systems Inc., 
as successor in interest by change in name only to Honeywell Bull Inc. and Honeywell Information Systems Inc. .

                                          -----------------------------------------------------------

Permission to use, copy, modify, and distribute these programs and their documentation for any purpose and without
fee is hereby granted,provided that the below copyright notice and historical background appear in all copies
and that both the copyright notice and historical background and this permission notice appear in supporting
documentation, and that the names of MIT, HIS, BULL or BULL HN not be used in advertising or publicity pertaining
to distribution of the programs without specific prior written permission.
    Copyright 1972 by Massachusetts Institute of Technology and Honeywell Information Systems Inc.
    Copyright 2006 by BULL HN Information Systems Inc.
    Copyright 2006 by Bull SAS
    All Rights Reserved