view etc/ledit.l @ 28230:8e330f701881

(Qx_charset_registry, Vface_default_registry): Variables removed. (clear_font_table, frame_update_line_height, load_face_font): Adjusted for the change of fontset implementation. (load_face_fontset_font): Function removed. (pixel_point_size): New function. (font_list): Argument type changed. Caller changed. (LFACE_FONT): New macro. (check_lface_attrs): Check attr[LFACE_FONT_INDEX]. (set_lface_from_font_name): Type of arg FONTNAME is changed to Lisp_Object. Determine the font name by actually loading a font by the specified pattern. Set LFACE_FONT (lface) to the specified pattern. Even if a font is not found, don't try alternatives. (Finternal_set_lisp_face_attribute): Handle `font' slot in lface. (set_font_frame_param): If `font' is specified in lface, use it. (Finternal_get_lisp_face_attribute): Handle `font' slot in lface. (lface_same_font_attributes_p): Likewise. (make_realized_face): Arguent changed. Caller changed. Set face->ascii_face to face itself. (free_realized_face): Free face->fontset if face is for ASCII. (face_suitable_for_iso8859_1_p, face_suitable_for_charset_p, deduce_unibyte_registry, x_charset_registry): Functions removed. (free_realized_multibyte_face): New function. (lookup_face, lookup_named_face, lookup_derived_face): Argument changed. Caller changed. (try_font_list): Argument type changed. (face_fontset): Check `font' slot of ATTRS, not `family' slot. (choose_face_font): Argument changed. Handle fontset properly. (choose_face_fontset_font): Function removed. (realize_default_face, realize_named_face): Don't remove the former face here. (realize_face): Argument changed. Caller changed. Remove face with the arg former_face_id in advance. Load font for the new face. (realize_x_face): Argument changed. Caller changed. For a multibyte character, share fontset with base_face. For a single byte character, make a new realized fontset. Don't load a font here. (realize_tty_face): Argument changed. Caller changed. (compute_char_face): Call FACE_FOR_CHAR, not FACE_FOR_CHARSET. (face_at_buffer_position): Don't check multibyte_p for returning DEFAULT_FACE_ID. (face_at_string_position): Call FACE_SUITABLE_FOR_CHAR_P, not FACE_SUITABLE_FOR_CHARSET_P. (syms_of_xfaces): Remove code for Qx_charset_registry and Vface_default_registry.

;;; -*- Mode: lisp -*-

; load in the c functions

(removeaddress '_signal)
(removeaddress '_switch_to_proc)
(removeaddress '_set_proc_str)

(cfasl "/src/mdc/ledit/leditcfns.o" '_switch_to_proc 'emacs)

(getaddress '_set_proc_str 'set_proc_str)

(declare (special *ledit-infile*               ; emacs->lisp tempfile
		  *ledit-outfile*              ; lisp->emacs tempfile
		  *ledit-ppfile*               ; pp->emacs tempfile
                  *ledit-lisztfile*            ; compiler input
                  *ledit-objfile*              ; compiler output
		  *ledit-initialized*)         ; flag
	 )

(setq *ledit-initialized* nil)

;;; INIT-LEDIT

(defun init-ledit ()
  (let ((user (getenv '|USER|)))		;USER must be uppercase
       (setq
	 *ledit-outfile* (concat "/tmp/" user ".l2") ; lisp -> emacs
	 *ledit-infile*  (concat "/tmp/" user ".l1") ; emacs -> lisp
	 *ledit-ppfile*  (concat "/tmp/" user ".l3") ; pp output to emacs.
	 *ledit-lisztfile*  (concat "/tmp/" user ".l4")
	 *ledit-objfile*  (concat "/tmp/" user ".o")
	 *ledit-initialized* t)))

;;; LEDIT
; if 1 arg, arg is taken as a tag name to pass to emacs.
; if 2 args, second arg is a keyword.  If 2nd arg is pp,
; pp is applied to first arg, and result is sent to emacs
; to put in a buffer called LEDIT (which is first erased.)

(defun ledit fexpr (args)
    (apply #'ledit* args))

;;; LEDIT*

(defun ledit* n
    (if (not *ledit-initialized*) (init-ledit))
    (ledit-output (listify n))
    (syscall 10. *ledit-infile*)        ; syscall 10 is "delete"
    (syscall 10. *ledit-lisztfile*)
    (emacs)
    (ledit-input)
    (syscall 10. *ledit-outfile*)
    (syscall 10. *ledit-ppfile*)
    t)

;;; LEDIT-OUTPUT
;;; Egad, what a mess!  Doesn't work for XEMACS yet.
;;; Here's an example from Mocklisp:
;;; -> (defun bar (nothing) (bar nothing))
;;; bar
;;; -> (ledit bar)
;;; should produce...
;;; (progn) (progn tag (setq tag "bar") (&goto-tag))
;;; and
;;; -> (ledit bar pp)
;;; should stuff this to emacs...
;;; (progn) (switch-to-buffer "LEDIT") (erase-buffer)
;;; (insert-file "/tmp/walter.l3") (lisp-mode)
;;; and this...
;;; (def bar
;;;   (lambda (x)
;;;    (bar nothing)))
;;; into *LEDIT*

(defun ledit-output (args)
  (if args
      (let ((ofile (outfile *ledit-outfile*)))
	   (format ofile "(progn)")             ; this is necessary.

	   (cond ((null (cdr args)) ; no keyword -> arg is a tag.
		  (format ofile "(progn tag (setq tag \"~A\"~
			         (&goto-tag))"
			         (car args)))
		 ((eq (cadr args) 'pp)       ; pp-> pp first arg to emacs
		      (apply 'pp `((|F| ,*ledit-ppfile*) ,(car args)))
		      (format ofile "(switch-to-buffer \"LEDIT\")~
				     (erase-buffer)")
		      (format ofile "(insert-file \"~A\")"
			             *ledit-ppfile*)
		      (format ofile "(lisp-mode)"))
	   
		 (t (format t "~&~A -- unknown option~%" (cdr args))))
	   (close ofile))))

;;; LISZT*
;;; Need this guy to do compile-input.
;;; Liszt returns 0 if all was well.
;;; Note that in ordinary use the user will have to get used to looking
;;; at "%Warning: ... Compiler declared *foo* special" messages, since
;;; you don't usually want to hunt around in your file, zap in the the
;;; declarations, then go back to what you were doing.
;;; Fortunately this doesn't cause the compiler to bomb.
;;; Some sleepless night I will think of a way to get around this.

(defun liszt* (&rest args)
   (apply #'liszt args))

;;; LEDIT-INPUT
;;; Although there are two cases here, in practice
;;; it is never the case that there is both input to be
;;; interpreted and input to be compiled.

(defun ledit-input ()
  (if (probef *ledit-lisztfile*)
      (cond ((getd #'liszt)
	     (format t ";Compiling LEDIT:")
	     (and (zerop (liszt* *ledit-lisztfile* '-o *ledit-objfile*))
		  (load *ledit-objfile*)))
	    (t (format t ";Can't compile LEDIT: No liszt.~%;Reading instead:")
	       (let ((ifile (infile *ledit-lisztfile*)))
		 (ledit-load ifile)
		 (close ifile)))))

  (if (probef *ledit-infile*)
      (let ((ifile (infile *ledit-infile*)))
	(format t ";Reading from LEDIT:~%")
	(ledit-load ifile)
	(close ifile))))

;;; LEDIT-LOAD
;;; A generally useful form of load

(defun ledit-load (ifile)
  (let ((eof-form (list 'eof-form)))
    (do ((form (read ifile eof-form) (read ifile eof-form)))
      ((eq form eof-form))
      (format t ";  ~A~%" (eval form)))))

(setsyntax #/ 'macro 'ledit)                  ; make ^E = (ledit)<return>

;; more robust version of the c function set_proc_str. Does argument checking.
;; set_proc_str sets the string that is stuffed to the tty after franz pauses
;; and the csh wakes up. It is usually "%emacs" or "%vemacs" or "%?emacs"
(defun set-proc-str (arg)
  (if (stringp arg)
    (set_proc_str arg)
    (if (symbolp arg)
      (set_proc_str (get-pname arg))
      (error arg " is illegal argument to set-proc-str"))))