-
Notifications
You must be signed in to change notification settings - Fork 0
/
swank-backend.lisp
1513 lines (1238 loc) · 52.7 KB
/
swank-backend.lisp
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
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
;;; -*- indent-tabs-mode: nil; outline-regexp: ";;;;;*" -*-
;;;
;;; slime-backend.lisp --- SLIME backend interface.
;;;
;;; Created by James Bielman in 2003. Released into the public domain.
;;;
;;;; Frontmatter
;;;
;;; This file defines the functions that must be implemented
;;; separately for each Lisp. Each is declared as a generic function
;;; for which swank-<implementation>.lisp provides methods.
(defpackage :swank-backend
(:use :common-lisp)
(:export #:*debug-swank-backend*
#:sldb-condition
#:compiler-condition
#:original-condition
#:message
#:source-context
#:condition
#:severity
#:with-compilation-hooks
#:location
#:location-p
#:location-buffer
#:location-position
#:position-p
#:position-pos
#:print-output-to-string
#:quit-lisp
#:references
#:unbound-slot-filler
#:declaration-arglist
#:type-specifier-arglist
#:with-struct
#:when-let
;; interrupt macro for the backend
#:*pending-slime-interrupts*
#:check-slime-interrupts
#:*interrupt-queued-handler*
;; inspector related symbols
#:emacs-inspect
#:label-value-line
#:label-value-line*
#:with-symbol))
(defpackage :swank-mop
(:use)
(:export
;; classes
#:standard-generic-function
#:standard-slot-definition
#:standard-method
#:standard-class
#:eql-specializer
#:eql-specializer-object
;; standard-class readers
#:class-default-initargs
#:class-direct-default-initargs
#:class-direct-slots
#:class-direct-subclasses
#:class-direct-superclasses
#:class-finalized-p
#:class-name
#:class-precedence-list
#:class-prototype
#:class-slots
#:specializer-direct-methods
;; generic function readers
#:generic-function-argument-precedence-order
#:generic-function-declarations
#:generic-function-lambda-list
#:generic-function-methods
#:generic-function-method-class
#:generic-function-method-combination
#:generic-function-name
;; method readers
#:method-generic-function
#:method-function
#:method-lambda-list
#:method-specializers
#:method-qualifiers
;; slot readers
#:slot-definition-allocation
#:slot-definition-documentation
#:slot-definition-initargs
#:slot-definition-initform
#:slot-definition-initfunction
#:slot-definition-name
#:slot-definition-type
#:slot-definition-readers
#:slot-definition-writers
#:slot-boundp-using-class
#:slot-value-using-class
#:slot-makunbound-using-class
;; generic function protocol
#:compute-applicable-methods-using-classes
#:finalize-inheritance))
(in-package :swank-backend)
;;;; Metacode
(defparameter *debug-swank-backend* nil
"If this is true, backends should not catch errors but enter the
debugger where appropriate. Also, they should not perform backtrace
magic but really show every frame including SWANK related ones.")
(defparameter *interface-functions* '()
"The names of all interface functions.")
(defparameter *unimplemented-interfaces* '()
"List of interface functions that are not implemented.
DEFINTERFACE adds to this list and DEFIMPLEMENTATION removes.")
(defmacro definterface (name args documentation &rest default-body)
"Define an interface function for the backend to implement.
A function is defined with NAME, ARGS, and DOCUMENTATION. This
function first looks for a function to call in NAME's property list
that is indicated by 'IMPLEMENTATION; failing that, it looks for a
function indicated by 'DEFAULT. If neither is present, an error is
signaled.
If a DEFAULT-BODY is supplied, then a function with the same body and
ARGS will be added to NAME's property list as the property indicated
by 'DEFAULT.
Backends implement these functions using DEFIMPLEMENTATION."
(check-type documentation string "a documentation string")
(assert (every #'symbolp args) ()
"Complex lambda-list not supported: ~S ~S" name args)
(labels ((gen-default-impl ()
`(setf (get ',name 'default) (lambda ,args ,@default-body)))
(args-as-list (args)
(destructuring-bind (req opt key rest) (parse-lambda-list args)
`(,@req ,@opt
,@(loop for k in key append `(,(kw k) ,k))
,@(or rest '(())))))
(parse-lambda-list (args)
(parse args '(&optional &key &rest)
(make-array 4 :initial-element nil)))
(parse (args keywords vars)
(cond ((null args)
(reverse (map 'list #'reverse vars)))
((member (car args) keywords)
(parse (cdr args) (cdr (member (car args) keywords)) vars))
(t (push (car args) (aref vars (length keywords)))
(parse (cdr args) keywords vars))))
(kw (s) (intern (string s) :keyword)))
`(progn
(defun ,name ,args
,documentation
(let ((f (or (get ',name 'implementation)
(get ',name 'default))))
(cond (f (apply f ,@(args-as-list args)))
(t (error "~S not implemented" ',name)))))
(pushnew ',name *interface-functions*)
,(if (null default-body)
`(pushnew ',name *unimplemented-interfaces*)
(gen-default-impl))
(eval-when (:compile-toplevel :load-toplevel :execute)
(export ',name :swank-backend))
',name)))
(defmacro defimplementation (name args &body body)
(assert (every #'symbolp args) ()
"Complex lambda-list not supported: ~S ~S" name args)
`(progn
(setf (get ',name 'implementation)
;; For implicit BLOCK. FLET because of interplay w/ decls.
(flet ((,name ,args ,@body)) #',name))
(if (member ',name *interface-functions*)
(setq *unimplemented-interfaces*
(remove ',name *unimplemented-interfaces*))
(warn "DEFIMPLEMENTATION of undefined interface (~S)" ',name))
',name))
(defun warn-unimplemented-interfaces ()
"Warn the user about unimplemented backend features.
The portable code calls this function at startup."
(let ((*print-pretty* t))
(warn "These Swank interfaces are unimplemented:~% ~:<~{~A~^ ~:_~}~:>"
(list (sort (copy-list *unimplemented-interfaces*) #'string<)))))
(defun import-to-swank-mop (symbol-list)
(dolist (sym symbol-list)
(let* ((swank-mop-sym (find-symbol (symbol-name sym) :swank-mop)))
(when swank-mop-sym
(unintern swank-mop-sym :swank-mop))
(import sym :swank-mop)
(export sym :swank-mop))))
(defun import-swank-mop-symbols (package except)
"Import the mop symbols from PACKAGE to SWANK-MOP.
EXCEPT is a list of symbol names which should be ignored."
(do-symbols (s :swank-mop)
(unless (member s except :test #'string=)
(let ((real-symbol (find-symbol (string s) package)))
(assert real-symbol () "Symbol ~A not found in package ~A" s package)
(unintern s :swank-mop)
(import real-symbol :swank-mop)
(export real-symbol :swank-mop)))))
(defvar *gray-stream-symbols*
'(:fundamental-character-output-stream
:stream-write-char
:stream-write-string
:stream-fresh-line
:stream-force-output
:stream-finish-output
:fundamental-character-input-stream
:stream-read-char
:stream-peek-char
:stream-read-line
;; STREAM-FILE-POSITION is not available on all implementations, or
;; partially under a different name.
; :stream-file-posiion
:stream-listen
:stream-unread-char
:stream-clear-input
:stream-line-column
:stream-read-char-no-hang
;; STREAM-LINE-LENGTH is an extension to gray streams that's apparently
;; supported by CMUCL, OpenMCL, SBCL and SCL.
#+(or cmu openmcl sbcl scl)
:stream-line-length))
(defun import-from (package symbol-names &optional (to-package *package*))
"Import the list of SYMBOL-NAMES found in the package PACKAGE."
(dolist (name symbol-names)
(multiple-value-bind (symbol found) (find-symbol (string name) package)
(assert found () "Symbol ~A not found in package ~A" name package)
(import symbol to-package))))
;;;; Utilities
(defmacro with-struct ((conc-name &rest names) obj &body body)
"Like with-slots but works only for structs."
(check-type conc-name symbol)
(flet ((reader (slot)
(intern (concatenate 'string
(symbol-name conc-name)
(symbol-name slot))
(symbol-package conc-name))))
(let ((tmp (gensym "OO-")))
` (let ((,tmp ,obj))
(symbol-macrolet
,(loop for name in names collect
(typecase name
(symbol `(,name (,(reader name) ,tmp)))
(cons `(,(first name) (,(reader (second name)) ,tmp)))
(t (error "Malformed syntax in WITH-STRUCT: ~A" name))))
,@body)))))
(defmacro when-let ((var value) &body body)
`(let ((,var ,value))
(when ,var ,@body)))
(defun with-symbol (name package)
"Generate a form suitable for testing with #+."
(if (and (find-package package)
(find-symbol (string name) package))
'(:and)
'(:or)))
;;;; UFT8
(deftype octet () '(unsigned-byte 8))
(deftype octets () '(simple-array octet (*)))
;; Helper function. Decode the next N bytes starting from INDEX.
;; Return the decoded char and the new index.
(defun utf8-decode-aux (buffer index limit byte0 n)
(declare (type octets buffer) (fixnum index limit byte0 n))
(if (< (- limit index) n)
(values nil index)
(do ((i 0 (1+ i))
(code byte0 (let ((byte (aref buffer (+ index i))))
(cond ((= (ldb (byte 2 6) byte) #b10)
(+ (ash code 6) (ldb (byte 6 0) byte)))
(t
(error "Invalid encoding"))))))
((= i n)
(values (cond ((<= code #xff) (code-char code))
((<= #xd800 code #xdfff)
(error "Invalid Unicode code point: #x~x" code))
((and (< code char-code-limit)
(code-char code)))
(t
(error
"Can't represent code point: #x~x ~
(char-code-limit is #x~x)"
code char-code-limit)))
(+ index n))))))
;; Decode one character in BUFFER starting at INDEX.
;; Return 2 values: the character and the new index.
;; If there aren't enough bytes between INDEX and LIMIT return nil.
(defun utf8-decode (buffer index limit)
(declare (type octets buffer) (fixnum index limit))
(if (= index limit)
(values nil index)
(let ((b (aref buffer index)))
(if (<= b #x7f)
(values (code-char b) (1+ index))
(macrolet ((try (marker else)
(let* ((l (integer-length marker))
(n (- l 2)))
`(if (= (ldb (byte ,l ,(- 8 l)) b) ,marker)
(utf8-decode-aux buffer (1+ index) limit
(ldb (byte ,(- 8 l) 0) b)
,n)
,else))))
(try #b110
(try #b1110
(try #b11110
(try #b111110
(try #b1111110
(error "Invalid encoding")))))))))))
;; Decode characters from BUFFER and write them to STRING.
;; Return 2 values: LASTINDEX and LASTSTART where
;; LASTINDEX is the last index in BUFFER that was not decoded
;; and LASTSTART is the last index in STRING not written.
(defun utf8-decode-into (buffer index limit string start end)
(declare (string string) (fixnum index limit start end) (type octets buffer))
(loop
(cond ((= start end)
(return (values index start)))
(t
(multiple-value-bind (c i) (utf8-decode buffer index limit)
(cond (c
(setf (aref string start) c)
(setq index i)
(setq start (1+ start)))
(t
(return (values index start)))))))))
(defun default-utf8-to-string (octets)
(let* ((limit (length octets))
(str (make-string limit)))
(multiple-value-bind (i s) (utf8-decode-into octets 0 limit str 0 limit)
(if (= i limit)
(if (= limit s)
str
(adjust-array str s))
(loop
(let ((end (+ (length str) (- limit i))))
(setq str (adjust-array str end))
(multiple-value-bind (i2 s2)
(utf8-decode-into octets i limit str s end)
(cond ((= i2 limit)
(return (adjust-array str s2)))
(t
(setq i i2)
(setq s s2))))))))))
(defmacro utf8-encode-aux (code buffer start end n)
`(cond ((< (- ,end ,start) ,n)
,start)
(t
(setf (aref ,buffer ,start)
(dpb (ldb (byte ,(- 7 n) ,(* 6 (1- n))) ,code)
(byte ,(- 7 n) 0)
,(dpb 0 (byte 1 (- 7 n)) #xff)))
,@(loop for i from 0 upto (- n 2) collect
`(setf (aref ,buffer (+ ,start ,(- n 1 i)))
(dpb (ldb (byte 6 ,(* 6 i)) ,code)
(byte 6 0)
#b10111111)))
(+ ,start ,n))))
(defun utf8-encode (char buffer start end)
(declare (character char) (type octets buffer) (fixnum start end))
(let ((code (char-code char)))
(cond ((<= code #x7f)
(cond ((< start end)
(setf (aref buffer start) code)
(1+ start))
(t start)))
((<= code #x7ff) (utf8-encode-aux code buffer start end 2))
((<= #xd800 code #xdfff)
(error "Invalid Unicode code point (surrogate): #x~x" code))
((<= code #xffff) (utf8-encode-aux code buffer start end 3))
((<= code #x1fffff) (utf8-encode-aux code buffer start end 4))
((<= code #x3ffffff) (utf8-encode-aux code buffer start end 5))
((<= code #x7fffffff) (utf8-encode-aux code buffer start end 6))
(t (error "Can't encode ~s (~x)" char code)))))
(defun utf8-encode-into (string start end buffer index limit)
(declare (string string) (type octets buffer) (fixnum start end index limit))
(loop
(cond ((= start end)
(return (values start index)))
((= index limit)
(return (values start index)))
(t
(let ((i2 (utf8-encode (char string start) buffer index limit)))
(cond ((= i2 index)
(return (values start index)))
(t
(setq index i2)
(incf start))))))))
(defun default-string-to-utf8 (string)
(let* ((len (length string))
(b (make-array len :element-type 'octet)))
(multiple-value-bind (s i) (utf8-encode-into string 0 len b 0 len)
(if (= s len)
b
(loop
(let ((limit (+ (length b) (- len s))))
(setq b (coerce (adjust-array b limit) 'octets))
(multiple-value-bind (s2 i2)
(utf8-encode-into string s len b i limit)
(cond ((= s2 len)
(return (coerce (adjust-array b i2) 'octets)))
(t
(setq i i2)
(setq s s2))))))))))
(definterface string-to-utf8 (string)
"Convert the string STRING to a (simple-array (unsigned-byte 8))"
(default-string-to-utf8 string))
(definterface utf8-to-string (octets)
"Convert the (simple-array (unsigned-byte 8)) OCTETS to a string."
(default-utf8-to-string octets))
;;; Codepoint length
;; we don't need this anymore.
(definterface codepoint-length (string)
"Return the number of codepoints in STRING.
With some Lisps, like cmucl, LENGTH returns the number of UTF-16 code
units, but other Lisps return the number of codepoints. The slime
protocol wants string lengths in terms of codepoints."
(length string))
;;;; TCP server
(definterface create-socket (host port &key backlog)
"Create a listening TCP socket on interface HOST and port PORT.
BACKLOG queue length for incoming connections.")
(definterface local-port (socket)
"Return the local port number of SOCKET.")
(definterface close-socket (socket)
"Close the socket SOCKET.")
(definterface accept-connection (socket &key external-format
buffering timeout)
"Accept a client connection on the listening socket SOCKET.
Return a stream for the new connection.
If EXTERNAL-FORMAT is nil return a binary stream
otherwise create a character stream.
BUFFERING can be one of:
nil ... no buffering
t ... enable buffering
:line ... enable buffering with automatic flushing on eol.")
(definterface add-sigio-handler (socket fn)
"Call FN whenever SOCKET is readable.")
(definterface remove-sigio-handlers (socket)
"Remove all sigio handlers for SOCKET.")
(definterface add-fd-handler (socket fn)
"Call FN when Lisp is waiting for input and SOCKET is readable.")
(definterface remove-fd-handlers (socket)
"Remove all fd-handlers for SOCKET.")
(definterface preferred-communication-style ()
"Return one of the symbols :spawn, :sigio, :fd-handler, or NIL."
nil)
(definterface set-stream-timeout (stream timeout)
"Set the 'stream 'timeout. The timeout is either the real number
specifying the timeout in seconds or 'nil for no timeout."
(declare (ignore stream timeout))
nil)
;;; Base condition for networking errors.
(define-condition network-error (simple-error) ())
(definterface emacs-connected ()
"Hook called when the first connection from Emacs is established.
Called from the INIT-FN of the socket server that accepts the
connection.
This is intended for setting up extra context, e.g. to discover
that the calling thread is the one that interacts with Emacs."
nil)
;;;; Unix signals
(defconstant +sigint+ 2)
(definterface getpid ()
"Return the (Unix) process ID of this superior Lisp.")
(definterface install-sigint-handler (function)
"Call FUNCTION on SIGINT (instead of invoking the debugger).
Return old signal handler."
(declare (ignore function))
nil)
(definterface call-with-user-break-handler (handler function)
"Install the break handler HANDLER while executing FUNCTION."
(let ((old-handler (install-sigint-handler handler)))
(unwind-protect (funcall function)
(install-sigint-handler old-handler))))
(definterface quit-lisp ()
"Exit the current lisp image.")
(definterface lisp-implementation-type-name ()
"Return a short name for the Lisp implementation."
(lisp-implementation-type))
(definterface lisp-implementation-program ()
"Return the argv[0] of the running Lisp process, or NIL."
(let ((file (car (command-line-args))))
(when (and file (probe-file file))
(namestring (truename file)))))
(definterface socket-fd (socket-stream)
"Return the file descriptor for SOCKET-STREAM.")
(definterface make-fd-stream (fd external-format)
"Create a character stream for the file descriptor FD.")
(definterface dup (fd)
"Duplicate a file descriptor.
If the syscall fails, signal a condition.
See dup(2).")
(definterface exec-image (image-file args)
"Replace the current process with a new process image.
The new image is created by loading the previously dumped
core file IMAGE-FILE.
ARGS is a list of strings passed as arguments to
the new image.
This is thin wrapper around exec(3).")
(definterface command-line-args ()
"Return a list of strings as passed by the OS."
nil)
;; pathnames are sooo useless
(definterface filename-to-pathname (filename)
"Return a pathname for FILENAME.
A filename in Emacs may for example contain asterisks which should not
be translated to wildcards."
(parse-namestring filename))
(definterface pathname-to-filename (pathname)
"Return the filename for PATHNAME."
(namestring pathname))
(definterface default-directory ()
"Return the default directory."
(directory-namestring (truename *default-pathname-defaults*)))
(definterface set-default-directory (directory)
"Set the default directory.
This is used to resolve filenames without directory component."
(setf *default-pathname-defaults* (truename (merge-pathnames directory)))
(default-directory))
(definterface call-with-syntax-hooks (fn)
"Call FN with hooks to handle special syntax."
(funcall fn))
(definterface default-readtable-alist ()
"Return a suitable initial value for SWANK:*READTABLE-ALIST*."
'())
;;;; Compilation
(definterface call-with-compilation-hooks (func)
"Call FUNC with hooks to record compiler conditions.")
(defmacro with-compilation-hooks ((&rest ignore) &body body)
"Execute BODY as in CALL-WITH-COMPILATION-HOOKS."
(declare (ignore ignore))
`(call-with-compilation-hooks (lambda () (progn ,@body))))
(definterface swank-compile-string (string &key buffer position filename
policy)
"Compile source from STRING.
During compilation, compiler conditions must be trapped and
resignalled as COMPILER-CONDITIONs.
If supplied, BUFFER and POSITION specify the source location in Emacs.
Additionally, if POSITION is supplied, it must be added to source
positions reported in compiler conditions.
If FILENAME is specified it may be used by certain implementations to
rebind *DEFAULT-PATHNAME-DEFAULTS* which may improve the recording of
source information.
If POLICY is supplied, and non-NIL, it may be used by certain
implementations to compile with optimization qualities of its
value.
Should return T on successful compilation, NIL otherwise.
")
(definterface swank-compile-file (input-file output-file load-p
external-format
&key policy)
"Compile INPUT-FILE signalling COMPILE-CONDITIONs.
If LOAD-P is true, load the file after compilation.
EXTERNAL-FORMAT is a value returned by find-external-format or
:default.
If POLICY is supplied, and non-NIL, it may be used by certain
implementations to compile with optimization qualities of its
value.
Should return OUTPUT-TRUENAME, WARNINGS-P and FAILURE-p
like `compile-file'")
(deftype severity ()
'(member :error :read-error :warning :style-warning :note :redefinition))
;; Base condition type for compiler errors, warnings and notes.
(define-condition compiler-condition (condition)
((original-condition
;; The original condition thrown by the compiler if appropriate.
;; May be NIL if a compiler does not report using conditions.
:type (or null condition)
:initarg :original-condition
:accessor original-condition)
(severity :type severity
:initarg :severity
:accessor severity)
(message :initarg :message
:accessor message)
;; Macro expansion history etc. which may be helpful in some cases
;; but is often very verbose.
(source-context :initarg :source-context
:type (or null string)
:initform nil
:accessor source-context)
(references :initarg :references
:initform nil
:accessor references)
(location :initarg :location
:accessor location)))
(definterface find-external-format (coding-system)
"Return a \"external file format designator\" for CODING-SYSTEM.
CODING-SYSTEM is Emacs-style coding system name (a string),
e.g. \"latin-1-unix\"."
(if (equal coding-system "iso-latin-1-unix")
:default
nil))
(definterface guess-external-format (pathname)
"Detect the external format for the file with name pathname.
Return nil if the file contains no special markers."
;; Look for a Emacs-style -*- coding: ... -*- or Local Variable: section.
(with-open-file (s pathname :if-does-not-exist nil
:external-format (or (find-external-format "latin-1-unix")
:default))
(if s
(or (let* ((line (read-line s nil))
(p (search "-*-" line)))
(when p
(let* ((start (+ p (length "-*-")))
(end (search "-*-" line :start2 start)))
(when end
(%search-coding line start end)))))
(let* ((len (file-length s))
(buf (make-string (min len 3000))))
(file-position s (- len (length buf)))
(read-sequence buf s)
(let ((start (search "Local Variables:" buf :from-end t))
(end (search "End:" buf :from-end t)))
(and start end (< start end)
(%search-coding buf start end))))))))
(defun %search-coding (str start end)
(let ((p (search "coding:" str :start2 start :end2 end)))
(when p
(incf p (length "coding:"))
(loop while (and (< p end)
(member (aref str p) '(#\space #\tab)))
do (incf p))
(let ((end (position-if (lambda (c) (find c '(#\space #\tab #\newline)))
str :start p)))
(find-external-format (subseq str p end))))))
;;;; Streams
(definterface make-output-stream (write-string)
"Return a new character output stream.
The stream calls WRITE-STRING when output is ready.")
(definterface make-input-stream (read-string)
"Return a new character input stream.
The stream calls READ-STRING when input is needed.")
;;;; Documentation
(definterface arglist (name)
"Return the lambda list for the symbol NAME. NAME can also be
a lisp function object, on lisps which support this.
The result can be a list or the :not-available keyword if the
arglist cannot be determined."
(declare (ignore name))
:not-available)
(defgeneric declaration-arglist (decl-identifier)
(:documentation
"Return the argument list of the declaration specifier belonging to the
declaration identifier DECL-IDENTIFIER. If the arglist cannot be determined,
the keyword :NOT-AVAILABLE is returned.
The different SWANK backends can specialize this generic function to
include implementation-dependend declaration specifiers, or to provide
additional information on the specifiers defined in ANSI Common Lisp.")
(:method (decl-identifier)
(case decl-identifier
(dynamic-extent '(&rest variables))
(ignore '(&rest variables))
(ignorable '(&rest variables))
(special '(&rest variables))
(inline '(&rest function-names))
(notinline '(&rest function-names))
(declaration '(&rest names))
(optimize '(&any compilation-speed debug safety space speed))
(type '(type-specifier &rest args))
(ftype '(type-specifier &rest function-names))
(otherwise
(flet ((typespec-p (symbol)
(member :type (describe-symbol-for-emacs symbol))))
(cond ((and (symbolp decl-identifier) (typespec-p decl-identifier))
'(&rest variables))
((and (listp decl-identifier)
(typespec-p (first decl-identifier)))
'(&rest variables))
(t :not-available)))))))
(defgeneric type-specifier-arglist (typespec-operator)
(:documentation
"Return the argument list of the type specifier belonging to
TYPESPEC-OPERATOR.. If the arglist cannot be determined, the keyword
:NOT-AVAILABLE is returned.
The different SWANK backends can specialize this generic function to
include implementation-dependend declaration specifiers, or to provide
additional information on the specifiers defined in ANSI Common Lisp.")
(:method (typespec-operator)
(declare (special *type-specifier-arglists*)) ; defined at end of file.
(typecase typespec-operator
(symbol (or (cdr (assoc typespec-operator *type-specifier-arglists*))
:not-available))
(t :not-available))))
(definterface type-specifier-p (symbol)
"Determine if SYMBOL is a type-specifier."
(or (documentation symbol 'type)
(not (eq (type-specifier-arglist symbol) :not-available))))
(definterface function-name (function)
"Return the name of the function object FUNCTION.
The result is either a symbol, a list, or NIL if no function name is
available."
(declare (ignore function))
nil)
(definterface valid-function-name-p (form)
"Is FORM syntactically valid to name a function?
If true, FBOUNDP should not signal a type-error for FORM."
(flet ((length=2 (list)
(and (not (null (cdr list))) (null (cddr list)))))
(or (symbolp form)
(and (consp form) (length=2 form)
(eq (first form) 'setf) (symbolp (second form))))))
(definterface macroexpand-all (form)
"Recursively expand all macros in FORM.
Return the resulting form.")
(definterface compiler-macroexpand-1 (form &optional env)
"Call the compiler-macro for form.
If FORM is a function call for which a compiler-macro has been
defined, invoke the expander function using *macroexpand-hook* and
return the results and T. Otherwise, return the original form and
NIL."
(let ((fun (and (consp form)
(valid-function-name-p (car form))
(compiler-macro-function (car form)))))
(if fun
(let ((result (funcall *macroexpand-hook* fun form env)))
(values result (not (eq result form))))
(values form nil))))
(definterface compiler-macroexpand (form &optional env)
"Repetitively call `compiler-macroexpand-1'."
(labels ((frob (form expanded)
(multiple-value-bind (new-form newly-expanded)
(compiler-macroexpand-1 form env)
(if newly-expanded
(frob new-form t)
(values new-form expanded)))))
(frob form env)))
(definterface format-string-expand (control-string)
"Expand the format string CONTROL-STRING."
(macroexpand `(formatter ,control-string)))
(definterface describe-symbol-for-emacs (symbol)
"Return a property list describing SYMBOL.
The property list has an entry for each interesting aspect of the
symbol. The recognised keys are:
:VARIABLE :FUNCTION :SETF :SPECIAL-OPERATOR :MACRO :COMPILER-MACRO
:TYPE :CLASS :ALIEN-TYPE :ALIEN-STRUCT :ALIEN-UNION :ALIEN-ENUM
The value of each property is the corresponding documentation string,
or NIL (or the obsolete :NOT-DOCUMENTED). It is legal to include keys
not listed here (but slime-print-apropos in Emacs must know about
them).
Properties should be included if and only if they are applicable to
the symbol. For example, only (and all) fbound symbols should include
the :FUNCTION property.
Example:
\(describe-symbol-for-emacs 'vector)
=> (:CLASS :NOT-DOCUMENTED
:TYPE :NOT-DOCUMENTED
:FUNCTION \"Constructs a simple-vector from the given objects.\")")
(definterface describe-definition (name type)
"Describe the definition NAME of TYPE.
TYPE can be any value returned by DESCRIBE-SYMBOL-FOR-EMACS.
Return a documentation string, or NIL if none is available.")
;;;; Debugging
(definterface install-debugger-globally (function)
"Install FUNCTION as the debugger for all threads/processes. This
usually involves setting *DEBUGGER-HOOK* and, if the implementation
permits, hooking into BREAK as well."
(setq *debugger-hook* function))
(definterface call-with-debugging-environment (debugger-loop-fn)
"Call DEBUGGER-LOOP-FN in a suitable debugging environment.
This function is called recursively at each debug level to invoke the
debugger loop. The purpose is to setup any necessary environment for
other debugger callbacks that will be called within the debugger loop.
For example, this is a reasonable place to compute a backtrace, switch
to safe reader/printer settings, and so on.")
(definterface call-with-debugger-hook (hook fun)
"Call FUN and use HOOK as debugger hook. HOOK can be NIL.
HOOK should be called for both BREAK and INVOKE-DEBUGGER."
(let ((*debugger-hook* hook))
(funcall fun)))
(define-condition sldb-condition (condition)
((original-condition
:initarg :original-condition
:accessor original-condition))
(:report (lambda (condition stream)
(format stream "Condition in debugger code~@[: ~A~]"
(original-condition condition))))
(:documentation
"Wrapper for conditions that should not be debugged.
When a condition arises from the internals of the debugger, it is not
desirable to debug it -- we'd risk entering an endless loop trying to
debug the debugger! Instead, such conditions can be reported to the
user without (re)entering the debugger by wrapping them as
`sldb-condition's."))
;;; The following functions in this section are supposed to be called
;;; within the dynamic contour of CALL-WITH-DEBUGGING-ENVIRONMENT only.
(definterface compute-backtrace (start end)
"Returns a backtrace of the condition currently being debugged,
that is an ordered list consisting of frames. ``Ordered list''
means that an integer I can be mapped back to the i-th frame of this
backtrace.
START and END are zero-based indices constraining the number of frames
returned. Frame zero is defined as the frame which invoked the
debugger. If END is nil, return the frames from START to the end of
the stack.")
(definterface print-frame (frame stream)
"Print frame to stream.")
(definterface frame-restartable-p (frame)
"Is the frame FRAME restartable?.
Return T if `restart-frame' can safely be called on the frame."
(declare (ignore frame))
nil)
(definterface frame-source-location (frame-number)
"Return the source location for the frame associated to FRAME-NUMBER.")
(definterface frame-catch-tags (frame-number)
"Return a list of catch tags for being printed in a debugger stack
frame."
(declare (ignore frame-number))
'())
(definterface frame-locals (frame-number)
"Return a list of ((&key NAME ID VALUE) ...) where each element of
the list represents a local variable in the stack frame associated to
FRAME-NUMBER.
NAME, a symbol; the name of the local variable.
ID, an integer; used as primary key for the local variable, unique
relatively to the frame under operation.
value, an object; the value of the local variable.")
(definterface frame-var-value (frame-number var-id)
"Return the value of the local variable associated to VAR-ID
relatively to the frame associated to FRAME-NUMBER.")
(definterface disassemble-frame (frame-number)
"Disassemble the code for the FRAME-NUMBER.
The output should be written to standard output.
FRAME-NUMBER is a non-negative integer.")
(definterface eval-in-frame (form frame-number)
"Evaluate a Lisp form in the lexical context of a stack frame
in the debugger.
FRAME-NUMBER must be a positive integer with 0 indicating the
frame which invoked the debugger.
The return value is the result of evaulating FORM in the
appropriate context.")
(definterface frame-package (frame-number)
"Return the package corresponding to the frame at FRAME-NUMBER.
Return nil if the backend can't figure it out."
(declare (ignore frame-number))
nil)
(definterface frame-call (frame-number)
"Return a string representing a call to the entry point of a frame.")
(definterface return-from-frame (frame-number form)
"Unwind the stack to the frame FRAME-NUMBER and return the value(s)
produced by evaluating FORM in the frame context to its caller.
Execute any clean-up code from unwind-protect forms above the frame
during unwinding.
Return a string describing the error if it's not possible to return
from the frame.")
(definterface restart-frame (frame-number)
"Restart execution of the frame FRAME-NUMBER with the same arguments
as it was called originally.")
(definterface format-sldb-condition (condition)
"Format a condition for display in SLDB."
(princ-to-string condition))
(definterface condition-extras (condition)