]> dreyeck.freedombox.rocks Git - topic-maps.git/blob - patches/closure-common-19d0b.patch
feat: support basic XTM topic names (slice 21D)
[topic-maps.git] / patches / closure-common-19d0b.patch
1 --- a/encodings.lisp
2 +++ b/encodings.lisp
3 @@ -1,4 +1,6 @@
4 (in-package :runes-encoding)
5 +
6 +(defparameter *topic-maps-encoding-patch* "19d0b-1")
7
8 (eval-when (:compile-toplevel :load-toplevel :execute)
9 (defparameter +buffer-byte+
10 @@ -154,6 +156,7 @@
11 (when (%= wptr out-end)
12 (return))
13 (when (>= (%+ rptr 1) in-end)
14 + (when (and eof? (< rptr in-end)) (xerror "Incomplete UTF-16 code unit"))
15 (return))
16 (let* ((hi (aref in rptr))
17 (lo (aref in (%+ 1 rptr)))
18 @@ -161,22 +164,29 @@
19 (when (or (eql x #xFFFE) (eql x #xFFFF))
20 (xerror "not a valid code point: #x~X" x))
21 (when (<= #xDC00 x #xDFFF)
22 - (xerror "unexpected high surrogate: #x~X" x))
23 + (xerror "unexpected low surrogate: #x~X" x))
24 (when (<= #xD800 x #xDBFF)
25 - ;; seen low surrogate, look for high surrogate now
26 + ;; A high surrogate must be followed by a low surrogate.
27 (when (>= (%+ rptr 3) in-end)
28 + (when eof? (xerror "Incomplete UTF-16 surrogate pair"))
29 (return))
30 (let* ((hi2 (aref in (%+ 2 rptr)))
31 (lo2 (aref in (%+ 3 rptr)))
32 (y (logior (ash hi2 8) lo2)))
33 - (unless (<= #xDC00 x #xDFFF)
34 - (xerror "expected a high surrogate but found: #x~X" x))
35 + (unless (<= #xDC00 y #xDFFF)
36 + (xerror "expected a low surrogate but found: #x~X" y))
37 #-rune-is-utf-16
38 (progn
39 (setf x (logior (ash (%- x #xd7c0) 10) (%and y #x3FF)))
40 (setf rptr (%+ 2 rptr))))
41 ;; end of surrogate handling
42 )
43 + (when (= x #x0D)
44 + (when (and (< (- in-end rptr) 4) (not eof?)) (return))
45 + (when (and (>= (- in-end rptr) 4)
46 + (= (logior (ash (aref in (+ rptr 2)) 8) (aref in (+ rptr 3))) #x0A))
47 + (incf rptr 2))
48 + (setf x #x0A))
49 (setf (aref out wptr) x)
50 (setf rptr (%+ 2 rptr))
51 (setf wptr (%+ 1 wptr))))
52 @@ -191,6 +201,7 @@
53 (when (%= wptr out-end)
54 (return))
55 (when (>= (%+ rptr 1) in-end)
56 + (when (and eof? (< rptr in-end)) (xerror "Incomplete UTF-16 code unit"))
57 (return))
58 (let* ((lo (aref in rptr))
59 (hi (aref in (%+ 1 rptr)))
60 @@ -198,22 +209,29 @@
61 (when (or (eql x #xFFFE) (eql x #xFFFF))
62 (xerror "not a valid code point: #x~X" x))
63 (when (<= #xDC00 x #xDFFF)
64 - (xerror "unexpected high surrogate: #x~X" x))
65 + (xerror "unexpected low surrogate: #x~X" x))
66 (when (<= #xD800 x #xDBFF)
67 - ;; seen low surrogate, look for high surrogate now
68 + ;; A high surrogate must be followed by a low surrogate.
69 (when (>= (%+ rptr 3) in-end)
70 + (when eof? (xerror "Incomplete UTF-16 surrogate pair"))
71 (return))
72 (let* ((lo2 (aref in (%+ 2 rptr)))
73 (hi2 (aref in (%+ 3 rptr)))
74 (y (logior (ash hi2 8) lo2)))
75 - (unless (<= #xDC00 x #xDFFF)
76 - (xerror "expected a high surrogate but found: #x~X" x))
77 + (unless (<= #xDC00 y #xDFFF)
78 + (xerror "expected a low surrogate but found: #x~X" y))
79 #-rune-is-utf-16
80 (progn
81 (setf x (logior (ash (%- x #xd7c0) 10) (%and y #x3FF)))
82 (setf rptr (%+ 2 rptr))))
83 ;; end of surrogate handling
84 )
85 + (when (= x #x0D)
86 + (when (and (< (- in-end rptr) 4) (not eof?)) (return))
87 + (when (and (>= (- in-end rptr) 4)
88 + (= (logior (ash (aref in (+ rptr 3)) 8) (aref in (+ rptr 2))) #x0A))
89 + (incf rptr 2))
90 + (setf x #x0A))
91 (setf (aref out wptr) x)
92 (setf rptr (%+ 2 rptr))
93 (setf wptr (%+ 1 wptr))))
94 @@ -231,6 +249,11 @@
95 byte0)
96 (macrolet ((put (x)
97 `((lambda (x)
98 + (when (< x (cond ((< byte0 #x80) 0)
99 + ((< byte0 #xE0) #x80)
100 + ((< byte0 #xF0) #x800)
101 + (t #x10000)))
102 + (xerror "Overlong UTF-8 sequence"))
103 (when (or (<= #xD800 x #xDBFF)
104 (<= #xDC00 x #xDFFF))
105 (xerror "surrogate encoded in UTF-8: #x~X." x))
106 @@ -247,6 +270,11 @@
107 (setf (aref out wptr) x)
108 (setf wptr (%+ wptr 1)))))
109 ,x))
110 + (continuation (offset)
111 + `(let ((octet (aref in (%+ rptr ,offset))))
112 + (unless (<= #x80 octet #xBF)
113 + (xerror "Invalid UTF-8 continuation byte: #x~X" octet))
114 + octet))
115 (put1 (x)
116 `(progn
117 (setf (aref out wptr) ,x)
118 @@ -284,64 +312,40 @@
119 (xerror "Corrupted UTF-8 input (initial byte was #b~8,'0B)" byte0)
120 (setf rptr (%+ rptr 1)))
121
122 - ((%<= #|#b11000000|# byte0 #b11011111)
123 + ((%<= #xC2 byte0 #xDF)
124 (cond ((<= (%+ rptr 2) in-end)
125 (put
126 (dpb (ldb (byte 5 0) byte0) (byte 5 6)
127 - (dpb (ldb (byte 6 0) (aref in (%+ rptr 1))) (byte 6 0)
128 + (dpb (ldb (byte 6 0) (continuation 1)) (byte 6 0)
129 0)))
130 (setf rptr (%+ rptr 2)))
131 (t
132 + (when eof? (xerror "Incomplete UTF-8 sequence"))
133 (return))))
134
135 - ((%<= #|#b11100000|# byte0 #b11101111)
136 + ((%<= #xE0 byte0 #xEF)
137 (cond ((<= (%+ rptr 3) in-end)
138 (put
139 (dpb (ldb (byte 4 0) byte0) (byte 4 12)
140 - (dpb (ldb (byte 6 0) (aref in (%+ 1 rptr))) (byte 6 6)
141 - (dpb (ldb (byte 6 0) (aref in (%+ 2 rptr))) (byte 6 0)
142 + (dpb (ldb (byte 6 0) (continuation 1)) (byte 6 6)
143 + (dpb (ldb (byte 6 0) (continuation 2)) (byte 6 0)
144 0))))
145 (setf rptr (%+ rptr 3)))
146 (t
147 + (when eof? (xerror "Incomplete UTF-8 sequence"))
148 (return))))
149
150 - ((%<= #|#b11110000|# byte0 #b11110111)
151 + ((%<= #xF0 byte0 #xF4)
152 (cond ((<= (%+ rptr 4) in-end)
153 (put
154 (dpb (ldb (byte 3 0) byte0) (byte 3 18)
155 - (dpb (ldb (byte 6 0) (aref in (%+ 1 rptr))) (byte 6 12)
156 - (dpb (ldb (byte 6 0) (aref in (%+ 2 rptr))) (byte 6 6)
157 - (dpb (ldb (byte 6 0) (aref in (%+ 3 rptr))) (byte 6 0)
158 + (dpb (ldb (byte 6 0) (continuation 1)) (byte 6 12)
159 + (dpb (ldb (byte 6 0) (continuation 2)) (byte 6 6)
160 + (dpb (ldb (byte 6 0) (continuation 3)) (byte 6 0)
161 0)))))
162 (setf rptr (%+ rptr 4)))
163 (t
164 - (return))))
165 -
166 - ((%<= #|#b11111000|# byte0 #b11111011)
167 - (cond ((<= (%+ rptr 5) in-end)
168 - (put
169 - (dpb (ldb (byte 2 0) byte0) (byte 2 24)
170 - (dpb (ldb (byte 6 0) (aref in (%+ 1 rptr))) (byte 6 18)
171 - (dpb (ldb (byte 6 0) (aref in (%+ 2 rptr))) (byte 6 12)
172 - (dpb (ldb (byte 6 0) (aref in (%+ 3 rptr))) (byte 6 6)
173 - (dpb (ldb (byte 6 0) (aref in (%+ 4 rptr))) (byte 6 0)
174 - 0))))))
175 - (setf rptr (%+ rptr 5)))
176 - (t
177 - (return))))
178 -
179 - ((%<= #|#b11111100|# byte0 #b11111101)
180 - (cond ((<= (%+ rptr 6) in-end)
181 - (put
182 - (dpb (ldb (byte 1 0) byte0) (byte 1 30)
183 - (dpb (ldb (byte 6 0) (aref in (%+ 1 rptr))) (byte 6 24)
184 - (dpb (ldb (byte 6 0) (aref in (%+ 2 rptr))) (byte 6 18)
185 - (dpb (ldb (byte 6 0) (aref in (%+ 3 rptr))) (byte 6 12)
186 - (dpb (ldb (byte 6 0) (aref in (%+ 4 rptr))) (byte 6 6)
187 - (dpb (ldb (byte 6 0) (aref in (%+ 5 rptr))) (byte 6 0)
188 - 0)))))))
189 - (setf rptr (%+ rptr 6)))
190 - (t
191 + (when eof? (xerror "Incomplete UTF-8 sequence"))
192 (return))))
193
194 (t
195 --- a/xstream.lisp
196 +++ b/xstream.lisp
197 @@ -317,7 +317,7 @@
198 (initial-encoding :guess))
199 ;; XXX if initial-speed isn't 1, encoding will me munged up
200 (assert (eql initial-speed 1))
201 - (multiple-value-bind (encoding preread)
202 + (multiple-value-bind (encoding preread detection)
203 (if (eq initial-encoding :guess)
204 (figure-encoding os-stream)
205 (values initial-encoding nil))
206 @@ -337,6 +337,7 @@
207 :os-left-start 0
208 :os-left-end (length preread)
209 :encoding encoding
210 + :plist (list :initial-encoding encoding :encoding-detection detection)
211 :name name))))
212
213 (defun make-rod-xstream (string &key name)
214 @@ -364,23 +365,26 @@
215 (values :utf-8 nil))
216
217 (defmethod figure-encoding ((stream stream))
218 - (let ((c0 (read-byte stream nil :eof)))
219 - (cond ((eq c0 :eof)
220 - (values :utf-8 nil))
221 - (t
222 - (let ((c1 (read-byte stream nil :eof)))
223 - (cond ((eq c1 :eof)
224 - (values :utf-8 (list c0)))
225 - (t
226 - (cond ((and (= c0 #xFE) (= c1 #xFF)) (values :utf-16-big-endian nil))
227 - ((and (= c0 #xFF) (= c1 #xFE)) (values :utf-16-little-endian nil))
228 - ((and (= c0 #xEF) (= c1 #xBB))
229 - (let ((c2 (read-byte stream nil :eof)))
230 - (if (= c2 #xBF)
231 - (values :utf-8 nil)
232 - (values :utf-8 (list c0 c1 c2)))))
233 - (t
234 - (values :utf-8 (list c0 c1)))))))))))
235 + ;; Keep preread bytes and distinguish a BOM from a provisional XML signature.
236 + (let* ((a (read-byte stream nil nil))
237 + (b (and a (read-byte stream nil nil)))
238 + (prefix (remove nil (list a b))))
239 + (cond ((equal prefix '(254 255)) (values :utf-16-big-endian nil :bom))
240 + ((equal prefix '(255 254)) (values :utf-16-little-endian nil :bom))
241 + ((equal prefix '(239 187))
242 + (let ((c (read-byte stream nil nil)))
243 + (if (eql c 191) (values :utf-8 nil :bom)
244 + (values :utf-8 (append prefix (and c (list c))) :default))))
245 + ((or (equal prefix '(0 60)) (equal prefix '(60 0)))
246 + (let* ((c (read-byte stream nil nil))
247 + (d (and c (read-byte stream nil nil)))
248 + (bytes (append prefix (remove nil (list c d)))))
249 + (cond ((equal bytes '(0 60 0 63))
250 + (values :utf-16-big-endian bytes :signature))
251 + ((equal bytes '(60 0 63 0))
252 + (values :utf-16-little-endian bytes :signature))
253 + (t (values :utf-8 bytes :default)))))
254 + (t (values :utf-8 prefix :default)))))
255
256 ;;; misc
257