blob: a66d1c321ea77a67d8dc02424ee231b498ec9be7 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
;;; -*- 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"))))
|
