|
0
|
1 ;;;; psgml-dtd.el --- DTD parser for SGML-editing mode with parsing support
|
|
|
2 ;; $Id: psgml-dtd.el,v 1.1.1.1 1996/12/18 03:35:19 steve Exp $
|
|
|
3
|
|
|
4 ;; Copyright (C) 1994 Lennart Staflin
|
|
|
5
|
|
|
6 ;; Author: Lennart Staflin <lenst@lysator.liu.se>
|
|
|
7
|
|
|
8 ;; This program is free software; you can redistribute it and/or
|
|
|
9 ;; modify it under the terms of the GNU General Public License
|
|
|
10 ;; as published by the Free Software Foundation; either version 2
|
|
|
11 ;; of the License, or (at your option) any later version.
|
|
|
12 ;;
|
|
|
13 ;; This program is distributed in the hope that it will be useful,
|
|
|
14 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
15 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
16 ;; GNU General Public License for more details.
|
|
|
17 ;;
|
|
|
18 ;; You should have received a copy of the GNU General Public License
|
|
|
19 ;; along with this program; if not, write to the Free Software
|
|
|
20 ;; Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
21
|
|
|
22
|
|
|
23 ;;;; Commentary:
|
|
|
24
|
|
|
25 ;; Part of major mode for editing the SGML document-markup language.
|
|
|
26
|
|
|
27
|
|
|
28 ;;;; Code:
|
|
|
29
|
|
|
30 (provide 'psgml-dtd)
|
|
|
31 (require 'psgml)
|
|
|
32 (require 'psgml-parse)
|
|
|
33
|
|
|
34
|
|
|
35 ;;;; Variables
|
|
|
36
|
|
|
37 ;; Variables used during doctype parsing and loading
|
|
|
38 (defvar sgml-used-pcdata nil
|
|
|
39 "True if model group built is mixed")
|
|
|
40
|
|
|
41
|
|
|
42 ;;;; Constructing basic
|
|
|
43
|
|
|
44 (defun sgml-copy-moves (s1 s2)
|
|
|
45 "Copy all moves from S1 to S2, keeping their status."
|
|
|
46 (let ((l (sgml-state-opts s1)))
|
|
|
47 (while l
|
|
|
48 (sgml-add-opt-move s2
|
|
|
49 (sgml-move-token (car l))
|
|
|
50 (sgml-move-dest (car l)))
|
|
|
51 (setq l (cdr l)))
|
|
|
52 (setq l (sgml-state-reqs s1))
|
|
|
53 (while l
|
|
|
54 (sgml-add-req-move s2
|
|
|
55 (sgml-move-token (car l))
|
|
|
56 (sgml-move-dest (car l)))
|
|
|
57 (setq l (cdr l)))))
|
|
|
58
|
|
|
59 (defun sgml-copy-moves-to-opt (s1 s2)
|
|
|
60 "Copy all moves from S1 to S2 as optional moves."
|
|
|
61 (let ((l (sgml-state-opts s1)))
|
|
|
62 (while l
|
|
|
63 (sgml-add-opt-move s2
|
|
|
64 (sgml-move-token (car l))
|
|
|
65 (sgml-move-dest (car l)))
|
|
|
66 (setq l (cdr l)))
|
|
|
67 (setq l (sgml-state-reqs s1))
|
|
|
68 (while l
|
|
|
69 (sgml-add-opt-move s2
|
|
|
70 (sgml-move-token (car l))
|
|
|
71 (sgml-move-dest (car l)))
|
|
|
72 (setq l (cdr l)))))
|
|
|
73
|
|
|
74
|
|
|
75 (defun sgml-some-states-of (state)
|
|
|
76 ;; List of some states reachable from STATE, includes all final states
|
|
|
77 (let* ((states (list state))
|
|
|
78 (l states)
|
|
|
79 s ms m)
|
|
|
80 (while l
|
|
|
81 (setq s (car l)
|
|
|
82 ms (append (sgml-state-opts s) (sgml-state-reqs s)))
|
|
|
83 (while ms
|
|
|
84 (setq m (sgml-move-dest (car ms))
|
|
|
85 ms (cdr ms))
|
|
|
86 (unless (sgml-normal-state-p m)
|
|
|
87 (setq m (sgml-&node-next m)))
|
|
|
88 (unless (memq m states)
|
|
|
89 (nconc states (list m))))
|
|
|
90 (setq l (cdr l)))
|
|
|
91 states))
|
|
|
92
|
|
|
93 (defmacro sgml-for-all-final-states (s dfa &rest forms)
|
|
|
94 "For all final states S in DFA do FORMS.
|
|
|
95 Syntax: var dfa-expr &body forms"
|
|
|
96 (` (let ((L-states (sgml-some-states-of (, dfa)))
|
|
|
97 (, s))
|
|
|
98 (while L-states
|
|
|
99 (when (sgml-state-final-p (setq (, s) (car L-states)))
|
|
|
100 (,@ forms))
|
|
|
101 (setq L-states (cdr L-states))))))
|
|
|
102
|
|
|
103 (put 'sgml-for-all-final-states 'lisp-indent-hook 2)
|
|
|
104 (put 'sgml-for-all-final-states 'edebug-form-hook '(symbolp &rest form))
|
|
|
105
|
|
|
106
|
|
|
107 ;;;; Optimization for the dfa building
|
|
|
108
|
|
|
109 (defsubst sgml-empty-state-p (s)
|
|
|
110 ;; True if S hase no outgoing moves
|
|
|
111 (and (sgml-normal-state-p s)
|
|
|
112 (null (sgml-state-reqs s))
|
|
|
113 (null (sgml-state-opts s))) )
|
|
|
114
|
|
|
115 (defun sgml-one-final-state (s)
|
|
|
116 ;; Collaps all states that have no moves
|
|
|
117 ;; This is a safe optimization, useful for (..|..|..)
|
|
|
118 (sgml-debug "OPT one final: reqs %d opts %d"
|
|
|
119 (length (sgml-state-reqs s))
|
|
|
120 (length (sgml-state-opts s)))
|
|
|
121 (let ((final nil)
|
|
|
122 dest)
|
|
|
123 (loop for m in (append (sgml-state-reqs s)
|
|
|
124 (sgml-state-opts s))
|
|
|
125 do
|
|
|
126 (setq dest (sgml-move-dest m))
|
|
|
127 (when (sgml-empty-state-p dest)
|
|
|
128 (cond ((null final)
|
|
|
129 (setq final dest))
|
|
|
130 (t
|
|
|
131 (setf (sgml-move-dest m) final)))))))
|
|
|
132
|
|
|
133 (defun sgml-states-equal (s1 s2)
|
|
|
134 (and (= (length (sgml-state-opts s1))
|
|
|
135 (length (sgml-state-opts s2)))
|
|
|
136 (= (length (sgml-state-reqs s1))
|
|
|
137 (length (sgml-state-reqs s2)))
|
|
|
138 (loop for m in (sgml-state-opts s1)
|
|
|
139 always
|
|
|
140 (eq (sgml-move-dest m)
|
|
|
141 (sgml-move-dest (sgml-moves-lookup (sgml-move-token m)
|
|
|
142 (sgml-state-opts s2)))))
|
|
|
143 (loop for m in (sgml-state-reqs s1)
|
|
|
144 always
|
|
|
145 (eq (sgml-move-dest m)
|
|
|
146 (sgml-move-dest (sgml-moves-lookup (sgml-move-token m)
|
|
|
147 (sgml-state-reqs s2)))))))
|
|
|
148
|
|
|
149 (defun sgml-remove-redundant-states-1 (s)
|
|
|
150 ;; Remove states accessible from s with one move and equivalent to s,
|
|
|
151 ;; by changing the moves from s.
|
|
|
152 (sgml-debug "OPT redundant-1: reqs %d opts %d"
|
|
|
153 (length (sgml-state-reqs s))
|
|
|
154 (length (sgml-state-opts s)))
|
|
|
155 (let ((yes nil)
|
|
|
156 (no (list s))
|
|
|
157 (l (sgml-state-reqs s))
|
|
|
158 (nl (sgml-state-opts s))
|
|
|
159 (res s)
|
|
|
160 dest)
|
|
|
161 (while (or l (setq l (prog1 nl (setq nl nil))))
|
|
|
162 (cond
|
|
|
163 ((not (sgml-normal-state-p (setq dest (sgml-move-dest (car l))))))
|
|
|
164 ((memq dest no))
|
|
|
165 ((memq dest yes))
|
|
|
166 ((sgml-states-equal s dest)
|
|
|
167 (progn (push dest yes))))
|
|
|
168 (setq l (cdr l)))
|
|
|
169 (setq l (sgml-state-opts s)
|
|
|
170 nl (sgml-state-reqs s))
|
|
|
171 (when yes
|
|
|
172 (sgml-debug "OPT redundant-1: sucess %s" (length yes))
|
|
|
173 (while (or l (setq l (prog1 nl (setq nl nil))))
|
|
|
174 (cond ((memq (sgml-move-dest (car l)) yes)
|
|
|
175 (setf (sgml-move-dest (car l)) s)))
|
|
|
176 (setq l (cdr l))))))
|
|
|
177
|
|
|
178
|
|
|
179
|
|
|
180 ;;;; Constructing
|
|
|
181
|
|
|
182 (defun sgml-make-opt (s1)
|
|
|
183 (when (sgml-state-reqs s1)
|
|
|
184 (setf (sgml-state-opts s1)
|
|
|
185 (nconc (sgml-state-opts s1)
|
|
|
186 (sgml-state-reqs s1)))
|
|
|
187 (setf (sgml-state-reqs s1) nil))
|
|
|
188 s1)
|
|
|
189
|
|
|
190 (defun sgml-make-* (s1)
|
|
|
191 (setq s1 (sgml-make-+ s1))
|
|
|
192 (when (sgml-state-reqs s1)
|
|
|
193 (sgml-make-opt s1))
|
|
|
194 (sgml-remove-redundant-states-1 s1)
|
|
|
195 s1)
|
|
|
196
|
|
|
197 (defun sgml-make-+ (s1)
|
|
|
198 (sgml-for-all-final-states s s1
|
|
|
199 (sgml-copy-moves-to-opt s1 s))
|
|
|
200 (sgml-remove-redundant-states-1 s1) ; optimize
|
|
|
201 s1)
|
|
|
202
|
|
|
203 (defun sgml-make-conc (s1 s2)
|
|
|
204 (let ((moves (append (sgml-state-reqs s1) (sgml-state-opts s1))))
|
|
|
205 (cond
|
|
|
206 (;; optimize the case where all moves from s1 goes to empty states
|
|
|
207 (loop for m in moves
|
|
|
208 always (sgml-empty-state-p (sgml-move-dest m)))
|
|
|
209 (loop for m in moves do (setf (sgml-move-dest m) s2))
|
|
|
210 (when (sgml-state-final-p s1)
|
|
|
211 (sgml-copy-moves s2 s1)))
|
|
|
212 (t ; general case
|
|
|
213 (sgml-for-all-final-states s s1
|
|
|
214 (sgml-copy-moves s2 s)
|
|
|
215 (sgml-remove-redundant-states-1 s)))))
|
|
|
216 s1)
|
|
|
217
|
|
|
218 (defun sgml-make-pcdata ()
|
|
|
219 (sgml-make-* (sgml-make-primitive-content-token sgml-pcdata-token)))
|
|
|
220
|
|
|
221 (defun sgml-reduce-, (l)
|
|
|
222 (while (cdr l)
|
|
|
223 (setcar (cdr l)
|
|
|
224 (sgml-make-conc (car l) (cadr l)))
|
|
|
225 (setq l (cdr l)))
|
|
|
226 (car l))
|
|
|
227
|
|
|
228 (defun sgml-reduce-| (l)
|
|
|
229 (while (cdr l) ; apply the binary make-alt
|
|
|
230 (cond ((or (sgml-state-final-p (car l)) ; is result optional
|
|
|
231 (sgml-state-final-p (cadr l)))
|
|
|
232 (sgml-make-opt (car l))
|
|
|
233 (sgml-copy-moves-to-opt (cadr l) (car l)))
|
|
|
234 (t
|
|
|
235 (sgml-copy-moves (cadr l) (car l))))
|
|
|
236 (setcdr l (cddr l)))
|
|
|
237 (sgml-one-final-state (car l)) ; optimization
|
|
|
238 (car l))
|
|
|
239
|
|
|
240 (defun sgml-make-& (dfas)
|
|
|
241 (let ((&n (sgml-make-&node dfas (sgml-make-state)))
|
|
|
242 (s (sgml-make-state))
|
|
|
243 (l dfas))
|
|
|
244 (while l ; For each si:
|
|
|
245 ;; For m in opts(si): add optional move from s to &n on token(m).
|
|
|
246 (loop for m in (sgml-state-opts (car l))
|
|
|
247 do (sgml-add-opt-move s (sgml-move-token m) &n))
|
|
|
248 ;; For m in reqs(si): add required move from s to &n on token(m).
|
|
|
249 (loop for m in (sgml-state-reqs (car l))
|
|
|
250 do (sgml-add-req-move s (sgml-move-token m) &n))
|
|
|
251 (setq l (cdr l)))
|
|
|
252 ;; Return s.
|
|
|
253 s))
|
|
|
254
|
|
|
255
|
|
|
256
|
|
|
257 ;(sgml-make-conc (sgml-make-primitive-content-token 'para) (sgml-make-primitive-content-token 'list))
|
|
|
258 ;(sgml-make-conc (sgml-make-& (list (sgml-make-primitive-content-token 'para) (sgml-make-primitive-content-token 'list))) (sgml-make-primitive-content-token 'foo))
|
|
|
259
|
|
|
260 ;(setq x (sgml-some-states-of (sgml-make-primitive-content-token 'para)))
|
|
|
261 ;(sgml-state-final-p (car x) )
|
|
|
262 ;(sgml-state-final-p (cadr x))
|
|
|
263
|
|
|
264
|
|
|
265 ;;;; Parse doctype: General
|
|
|
266
|
|
|
267 (defun sgml-skip-ts ()
|
|
|
268 ;; Skip over ts*
|
|
|
269 ;;70 ts = 5 s | EE | 60+ parameter entity reference
|
|
|
270 ;;For simplicity I use ps*
|
|
|
271 ;;65 ps = 5 s | EE | 60+ parameter entity reference | 92 comment
|
|
|
272 ;;*** some comments are accepted that shouldn't
|
|
|
273 (sgml-skip-ps))
|
|
|
274
|
|
|
275 (defun sgml-parse-character-reference (&optional dofunchar)
|
|
|
276 ;; *** Actually only numerical character references
|
|
|
277 ;; I don't know how to handel the function character references.
|
|
|
278 ;; For the shortrefs let's give them numeric values.
|
|
|
279 (if (if dofunchar
|
|
|
280 (sgml-parse-delim "CRO" (digit nmstart))
|
|
|
281 (sgml-parse-delim "CRO" (digit)))
|
|
|
282 (prog1 (if (sgml-is-delim "NULL" digit)
|
|
|
283 (string-to-int (sgml-check-nametoken))
|
|
|
284 (let ((spec (sgml-check-name)))
|
|
|
285 (or (cdr (assoc spec '(("re" . 10)
|
|
|
286 ("rs" . 1)
|
|
|
287 ("tab" . 9)
|
|
|
288 ("space" . 32))))
|
|
|
289 ;; *** What to do with other names?
|
|
|
290 127)))
|
|
|
291 (or (sgml-parse-delim "REFC")
|
|
|
292 (sgml-parse-RE)))))
|
|
|
293
|
|
|
294 (defun sgml-parse-parameter-literal (&optional dofunchar)
|
|
|
295 (let* (lita ; flag if lita
|
|
|
296 (value ; accumulates literals value
|
|
|
297 "")
|
|
|
298 (original-buffer ; Buffer (entity) where lit started
|
|
|
299 (current-buffer))
|
|
|
300 temp
|
|
|
301 )
|
|
|
302 (cond
|
|
|
303 ((or (sgml-parse-delim "LIT")
|
|
|
304 (setq lita (sgml-parse-delim "LITA")))
|
|
|
305 (while (not (and (eq (current-buffer) original-buffer)
|
|
|
306 (if lita
|
|
|
307 (sgml-parse-delim "LITA")
|
|
|
308 (sgml-parse-delim "LIT"))))
|
|
|
309 (cond ((eobp)
|
|
|
310 (or (sgml-pop-entity)
|
|
|
311 (sgml-error "Parameter literal unterminated")))
|
|
|
312 ((sgml-parse-parameter-entity-ref))
|
|
|
313 ((setq temp (sgml-parse-character-reference dofunchar))
|
|
|
314 (setq value (concat value (format "%c" temp))))
|
|
|
315 (t
|
|
|
316 (setq value
|
|
|
317 (concat value
|
|
|
318 (buffer-substring
|
|
|
319 (point)
|
|
|
320 (progn (forward-char 1)
|
|
|
321 (if lita
|
|
|
322 (sgml-skip-upto ("LITA" "PERO" "CRO"))
|
|
|
323 (sgml-skip-upto ("LIT" "PERO" "CRO")))
|
|
|
324 (point)))))))
|
|
|
325 )
|
|
|
326 value))))
|
|
|
327
|
|
|
328 (defun sgml-check-parameter-literal ()
|
|
|
329 (or (sgml-parse-parameter-literal)
|
|
|
330 (sgml-parse-error "Parameter literal expected")))
|
|
|
331
|
|
|
332 (defsubst sgml-parse-connector ()
|
|
|
333 (sgml-skip-ps)
|
|
|
334 (cond ((sgml-parse-delim "SEQ")
|
|
|
335 (function sgml-reduce-,))
|
|
|
336 ((sgml-parse-delim "OR")
|
|
|
337 (function sgml-reduce-|))
|
|
|
338 ((sgml-parse-delim "AND")
|
|
|
339 (function sgml-make-&))))
|
|
|
340
|
|
|
341 (defun sgml-parse-name-group ()
|
|
|
342 "Parse a single name or a name group (general name case) .
|
|
|
343 Returns a list of strings or nil."
|
|
|
344 (let (names)
|
|
|
345 (cond
|
|
|
346 ((sgml-parse-delim "GRPO")
|
|
|
347 (sgml-skip-ps)
|
|
|
348 (setq names (sgml-parse-name-group)) ; *** Allows more than it should
|
|
|
349 (while (sgml-parse-connector)
|
|
|
350 (sgml-skip-ps)
|
|
|
351 (nconc names (sgml-parse-name-group)))
|
|
|
352 (sgml-check-delim "GRPC")
|
|
|
353 names)
|
|
|
354 ((setq names (sgml-parse-name))
|
|
|
355 (list names)))))
|
|
|
356
|
|
|
357 (defun sgml-check-name-group ()
|
|
|
358 (or (sgml-parse-name-group)
|
|
|
359 (sgml-parse-error "Expecting a name or a name group")))
|
|
|
360
|
|
|
361 (defun sgml-check-nametoken-group ()
|
|
|
362 "Parse a name token group, return a list of strings.
|
|
|
363 Case transformed for general names."
|
|
|
364 (sgml-skip-ps)
|
|
|
365 (let ((names nil))
|
|
|
366 (cond
|
|
|
367 ((sgml-parse-delim GRPO)
|
|
|
368 (while (progn
|
|
|
369 (sgml-skip-ps)
|
|
|
370 (push (sgml-general-case (sgml-check-nametoken)) names)
|
|
|
371 (sgml-parse-connector)))
|
|
|
372 (sgml-check-delim GRPC)
|
|
|
373 (nreverse names)) ; store in same order as declared
|
|
|
374 (t
|
|
|
375 (list (sgml-general-case (sgml-check-nametoken)))))))
|
|
|
376
|
|
|
377 (defun sgml-check-element-type ()
|
|
|
378 "Parse and check an element type, returns list of strings."
|
|
|
379 ;;; 117 element type = [[30 generic identifier]]
|
|
|
380 ;;; | [[69 name group]]
|
|
|
381 ;;; | [[118 ranked element]]
|
|
|
382 ;;; | [[119 ranked group]]
|
|
|
383 (cond
|
|
|
384 ((sgml-parse-delim GRPO)
|
|
|
385 (sgml-skip-ts)
|
|
|
386 (let ((names (list (sgml-check-name))))
|
|
|
387 (while (progn (sgml-skip-ts)
|
|
|
388 (sgml-parse-connector))
|
|
|
389 (sgml-skip-ts)
|
|
|
390 (nconc names (list (sgml-check-name))))
|
|
|
391 (sgml-check-delim GRPC)
|
|
|
392 ;; A ranked group will have a rank suffix here
|
|
|
393 (sgml-skip-ps)
|
|
|
394 (if (sgml-is-delim "NULL" digit)
|
|
|
395 (let ((suffix (sgml-parse-nametoken)))
|
|
|
396 (loop for n in names
|
|
|
397 collect (concat n suffix)))
|
|
|
398 names)))
|
|
|
399 (t ; gi/ranked element
|
|
|
400 (let ((name (sgml-check-name)))
|
|
|
401 (sgml-skip-ps)
|
|
|
402 (list (if (sgml-is-delim "NULL" digit)
|
|
|
403 (concat name (sgml-check-nametoken))
|
|
|
404 name))))))
|
|
|
405
|
|
|
406
|
|
|
407 (defun sgml-check-external ()
|
|
|
408 (or (sgml-parse-external)
|
|
|
409 (sgml-parse-error "Expecting a PUBLIC or SYSTEM")))
|
|
|
410
|
|
|
411 ;;;; Parse doctype: notation
|
|
|
412
|
|
|
413 (defun sgml-declare-notation ()
|
|
|
414 ;;148 notation declaration = MDO, "NOTATION",
|
|
|
415 ;; 65 ps+, 41 notation name,
|
|
|
416 ;; 65 ps+, 149 notation identifier,
|
|
|
417 ;; 65 ps*, MDC
|
|
|
418 ;;41 notation name = 55 name
|
|
|
419 ;;149 notation identifier = 73 external identifier
|
|
|
420 (sgml-skip-ps)
|
|
|
421 (sgml-check-name)
|
|
|
422 (sgml-skip-ps)
|
|
|
423 (sgml-check-external))
|
|
|
424
|
|
|
425
|
|
|
426 ;;;; Parse doctype: Element
|
|
|
427
|
|
|
428 (defun sgml-parse-opt ()
|
|
|
429 (sgml-skip-ps)
|
|
|
430 (cond ((or (sgml-parse-char ?o)
|
|
|
431 (sgml-parse-char ?O))
|
|
|
432 t)
|
|
|
433 ((sgml-parse-char ?-)
|
|
|
434 nil)))
|
|
|
435
|
|
|
436 (defun sgml-parse-modifier ()
|
|
|
437 (cond ((sgml-parse-delim PLUS)
|
|
|
438 (function sgml-make-+))
|
|
|
439 ((sgml-parse-delim REP)
|
|
|
440 (function sgml-make-*))
|
|
|
441 ((sgml-parse-delim OPT)
|
|
|
442 (function sgml-make-opt))))
|
|
|
443
|
|
|
444 (defun sgml-check-primitive-content-token ()
|
|
|
445 (sgml-make-primitive-content-token
|
|
|
446 (sgml-eltype-token
|
|
|
447 (sgml-lookup-eltype
|
|
|
448 (sgml-check-name)))))
|
|
|
449
|
|
|
450 (defun sgml-check-model-group ()
|
|
|
451 (sgml-skip-ps)
|
|
|
452 (let (el mod)
|
|
|
453 (cond
|
|
|
454 ((sgml-parse-delim "GRPO")
|
|
|
455 (let ((subs (list (sgml-check-model-group)))
|
|
|
456 (con1 nil)
|
|
|
457 (con2 nil))
|
|
|
458 (while (setq con2 (sgml-parse-connector))
|
|
|
459 (cond ((and con1
|
|
|
460 (not (eq con1 con2)))
|
|
|
461 (sgml-parse-error "Mixed connectors")))
|
|
|
462 (setq con1 con2)
|
|
|
463 (setq subs (nconc subs (list (sgml-check-model-group)))))
|
|
|
464 (sgml-check-delim "GRPC")
|
|
|
465 (setq el (if con1
|
|
|
466 (funcall con1 subs)
|
|
|
467 (car subs)))))
|
|
|
468 ((sgml-parse-rni "pcdata") ; #PCDATA
|
|
|
469 (setq sgml-used-pcdata t)
|
|
|
470 (setq el (sgml-make-pcdata)))
|
|
|
471 ((sgml-parse-delim "DTGO") ; data tag group
|
|
|
472 (sgml-skip-ts)
|
|
|
473 (let ((tok (sgml-check-primitive-content-token)))
|
|
|
474 (sgml-skip-ts) (sgml-check-delim "SEQ")
|
|
|
475 (sgml-skip-ts) (sgml-check-data-tag-pattern)
|
|
|
476 (sgml-skip-ts) (sgml-check-delim "DTGC")
|
|
|
477 (setq el (sgml-make-conc tok (sgml-make-pcdata)))
|
|
|
478 (setq sgml-used-pcdata t)))
|
|
|
479 (t
|
|
|
480 (setq el (sgml-check-primitive-content-token))))
|
|
|
481 (setq mod (sgml-parse-modifier))
|
|
|
482 (if mod
|
|
|
483 (funcall mod el)
|
|
|
484 el)))
|
|
|
485
|
|
|
486 (defun sgml-check-data-tag-pattern ()
|
|
|
487 ;; 134 data tag pattern
|
|
|
488 ;; template | template group
|
|
|
489 (cond ((sgml-parse-delim GRPO)
|
|
|
490 (sgml-skip-ts)
|
|
|
491 (sgml-check-parameter-literal) ; data tag template,
|
|
|
492 (while (progn (sgml-skip-ts)
|
|
|
493 (sgml-parse-delim OR))
|
|
|
494 (sgml-skip-ts)
|
|
|
495 (sgml-check-parameter-literal)) ; data tag template
|
|
|
496 (sgml-skip-ts)
|
|
|
497 (sgml-check-delim GRPC))
|
|
|
498 (t
|
|
|
499 (sgml-check-parameter-literal))) ; data tag template
|
|
|
500 (sgml-skip-ts)
|
|
|
501 (when (sgml-parse-delim SEQ)
|
|
|
502 (sgml-check-parameter-literal))) ; data tag padding template
|
|
|
503
|
|
|
504 (defun sgml-check-content-model ()
|
|
|
505 (sgml-check-model-group))
|
|
|
506
|
|
|
507 (defun sgml-check-content ()
|
|
|
508 (sgml-skip-ps)
|
|
|
509 (cond ((sgml-is-delim GRPO)
|
|
|
510 (sgml-check-content-model))
|
|
|
511 (t
|
|
|
512 ;; ANY, CDATA, RCDATA or EMPTY
|
|
|
513 (let ((dc (intern (upcase (sgml-check-name)))))
|
|
|
514 (when (eq dc 'ANY)
|
|
|
515 (setq sgml-used-pcdata t))
|
|
|
516 dc))))
|
|
|
517
|
|
|
518 (defun sgml-parse-exeption (type)
|
|
|
519 (sgml-skip-ps)
|
|
|
520 (if (sgml-parse-char type)
|
|
|
521 (mapcar (function sgml-lookup-eltype)
|
|
|
522 (sgml-check-name-group))))
|
|
|
523
|
|
|
524 (defun sgml-before-eltype-modification ()
|
|
|
525 ;;; (let ((merged (sgml-dtd-merged sgml-dtd-info)))
|
|
|
526 ;;; (when (and merged
|
|
|
527 ;;; (eq (sgml-dtd-eltypes sgml-dtd-info)
|
|
|
528 ;;; (sgml-dtd-eltypes (cdr merged))))
|
|
|
529 ;;; (setf (sgml-dtd-eltypes sgml-dtd-info)
|
|
|
530 ;;; (sgml-merge-eltypes (sgml-make-eltypes-table)
|
|
|
531 ;;; (sgml-dtd-eltypes sgml-dtd-info)))))
|
|
|
532 )
|
|
|
533
|
|
|
534 (defun sgml-declare-element ()
|
|
|
535 (let* ((names (sgml-check-element-type))
|
|
|
536 (stag-opt (sgml-parse-opt))
|
|
|
537 (etag-opt (sgml-parse-opt))
|
|
|
538 (sgml-used-pcdata nil)
|
|
|
539 (model (sgml-check-content))
|
|
|
540 (exclusions (sgml-parse-exeption ?-))
|
|
|
541 (inclusions (sgml-parse-exeption ?+)))
|
|
|
542 (sgml-before-eltype-modification)
|
|
|
543 (while names
|
|
|
544 (sgml-debug "Defining element %s" (car names))
|
|
|
545 (let ((et (sgml-lookup-eltype (car names))))
|
|
|
546 (setf (sgml-eltype-stag-optional et) stag-opt
|
|
|
547 (sgml-eltype-etag-optional et) etag-opt
|
|
|
548 (sgml-eltype-model et) model
|
|
|
549 (sgml-eltype-mixed et) sgml-used-pcdata
|
|
|
550 (sgml-eltype-excludes et) exclusions
|
|
|
551 (sgml-eltype-includes et) inclusions))
|
|
|
552 (setq names (cdr names)))
|
|
|
553 (sgml-lazy-message "Parsing doctype (%s elements)..."
|
|
|
554 (incf sgml-no-elements))))
|
|
|
555
|
|
|
556 ;;;; Parse doctype: Entity
|
|
|
557
|
|
|
558 (defun sgml-declare-entity ()
|
|
|
559 (let (name ; Name of entity
|
|
|
560 dest ; Entity table
|
|
|
561 (type 'text) ; Type of entity
|
|
|
562 text ; Text of entity
|
|
|
563 extid ; External id
|
|
|
564 )
|
|
|
565 (cond
|
|
|
566 ((sgml-parse-delim "PERO") ; parameter entity declaration
|
|
|
567 (sgml-skip-ps)
|
|
|
568 (setq name (sgml-check-name t))
|
|
|
569 (setq dest (sgml-dtd-parameters sgml-dtd-info)))
|
|
|
570 (t ; normal entity declaration
|
|
|
571 (or (sgml-parse-rni "default")
|
|
|
572 (setq name (sgml-check-name t)))
|
|
|
573 (setq dest (sgml-dtd-entities sgml-dtd-info))))
|
|
|
574 (sgml-skip-ps)
|
|
|
575 ;;105 entity text = 66 parameter literal
|
|
|
576 ;; | 106 data text
|
|
|
577 ;; | 107 bracketed text
|
|
|
578 ;; | 108 external entity specification
|
|
|
579 (setq extid (sgml-parse-external))
|
|
|
580 (setq text
|
|
|
581 (cond
|
|
|
582 (extid ; external entity specification =
|
|
|
583 ; 73 external identifier,
|
|
|
584 ; (65 ps+, 109+ entity type)?
|
|
|
585 (sgml-skip-ps)
|
|
|
586 (setq type (or (sgml-parse-entity-type) 'text))
|
|
|
587 extid)
|
|
|
588 ((sgml-startnm-char-next)
|
|
|
589 (let ((token (intern (sgml-check-name))))
|
|
|
590 (sgml-skip-ps)
|
|
|
591 (cond
|
|
|
592 ((memq token '(cdata sdata)) ; data text ***
|
|
|
593 (setq type token)
|
|
|
594 (sgml-check-parameter-literal))
|
|
|
595 ((eq token 'pi)
|
|
|
596 (concat "<?" (sgml-check-parameter-literal) ">"))
|
|
|
597 ((eq token 'starttag)
|
|
|
598 (sgml-start-tag-of (sgml-check-parameter-literal)))
|
|
|
599 ((eq token 'endtag)
|
|
|
600 (sgml-end-tag-of (sgml-check-parameter-literal)))
|
|
|
601 ((eq token 'ms) ; marked section
|
|
|
602 (concat "<![" (sgml-check-parameter-literal) "]]>"))
|
|
|
603 ((eq token 'md) ; Markup declaration
|
|
|
604 (concat "<!" (sgml-check-parameter-literal) ">")))))
|
|
|
605 ((sgml-check-parameter-literal))))
|
|
|
606 (when dest
|
|
|
607 (sgml-entity-declare name dest type text))))
|
|
|
608
|
|
|
609
|
|
|
610 (defun sgml-parse-entity-type ()
|
|
|
611 ;;109+ entity type = "SUBDOC"
|
|
|
612 ;; | (("CDATA" | "NDATA" | "SDATA"),
|
|
|
613 ;; 65 ps+,
|
|
|
614 ;; 41 notation name,
|
|
|
615 ;; 149.2+ data attribute specification?)
|
|
|
616 (let ((type (sgml-parse-name)))
|
|
|
617 (when type
|
|
|
618 (setq type (intern (downcase type)))
|
|
|
619 (cond ((eq type 'subdoc))
|
|
|
620 ((memq type '(cdata ndata sdata))
|
|
|
621 (sgml-skip-ps)
|
|
|
622 (sgml-check-name)
|
|
|
623 ;;149.2+ data attribute specification
|
|
|
624 ;; = 65 ps+, DSO,
|
|
|
625 ;; 31 attribute specification list,
|
|
|
626 ;; 5 s*, DSC
|
|
|
627 (sgml-skip-ps)
|
|
|
628 (when (sgml-parse-delim DSO)
|
|
|
629 (sgml-parse-attribute-specification-list)
|
|
|
630 (sgml-parse-s)
|
|
|
631 (sgml-check-delim DSC)))
|
|
|
632 (t (sgml-error "Illegal entity type: %s" type))))
|
|
|
633 type))
|
|
|
634
|
|
|
635
|
|
|
636 ;;;; Parse doctype: Attlist
|
|
|
637
|
|
|
638 (defun sgml-declare-attlist ()
|
|
|
639 (let* ((assnot (cond ((sgml-parse-rni "notation")
|
|
|
640 (sgml-skip-ps)
|
|
|
641 t)))
|
|
|
642 (assel (sgml-check-name-group))
|
|
|
643 (attlist nil) ; the list
|
|
|
644 (attdef nil))
|
|
|
645 (while (setq attdef (sgml-parse-attribute-definition))
|
|
|
646 (push attdef attlist))
|
|
|
647 (setq attlist (nreverse attlist))
|
|
|
648 (unless assnot
|
|
|
649 (sgml-before-eltype-modification)
|
|
|
650 (loop for elname in assel do
|
|
|
651 (setf (sgml-eltype-attlist (sgml-lookup-eltype elname))
|
|
|
652 attlist)))))
|
|
|
653
|
|
|
654 (defun sgml-parse-attribute-definition ()
|
|
|
655 (sgml-skip-ps)
|
|
|
656 (if (sgml-is-delim MDC) ; End of attlist?
|
|
|
657 nil
|
|
|
658 (sgml-make-attdecl (sgml-check-name)
|
|
|
659 (sgml-check-declared-value)
|
|
|
660 (sgml-check-default-value))))
|
|
|
661
|
|
|
662 (defun sgml-check-declared-value ()
|
|
|
663 (sgml-skip-ps)
|
|
|
664 (let ((type 'name-token-group)
|
|
|
665 (names nil))
|
|
|
666 (unless (eq (following-char) ?\()
|
|
|
667 (setq type (intern (sgml-check-name)))
|
|
|
668 (sgml-skip-ps))
|
|
|
669 (when (memq type '(name-token-group notation))
|
|
|
670 (setq names (sgml-check-nametoken-group)))
|
|
|
671 (sgml-make-declared-value type names)))
|
|
|
672
|
|
|
673 (defun sgml-check-default-value ()
|
|
|
674 (sgml-skip-ps)
|
|
|
675 (let* ((rni (sgml-parse-rni))
|
|
|
676 (key (if rni (intern (sgml-check-name)))))
|
|
|
677 (sgml-skip-ps)
|
|
|
678 (sgml-make-default-value
|
|
|
679 key
|
|
|
680 (if (or (not rni) (eq key 'fixed))
|
|
|
681 (sgml-check-attribute-value-specification)))))
|
|
|
682
|
|
|
683
|
|
|
684 ;;;; Parse doctype: Shortref
|
|
|
685
|
|
|
686 ;;;150 short reference mapping declaration = MDO, "SHORTREF",
|
|
|
687 ;;; [[65 ps]]+, [[151 map name]],
|
|
|
688 ;;; ([[65 ps]]+, [[66 parameter literal]],
|
|
|
689 ;;; [[65 ps]]+, [[55 name]])+,
|
|
|
690 ;;; [[65 ps]]*, MDC
|
|
|
691
|
|
|
692 (defun sgml-declare-shortref ()
|
|
|
693 (let ((mapname (sgml-check-name))
|
|
|
694 mappings literal name)
|
|
|
695 (while (progn
|
|
|
696 (sgml-skip-ps)
|
|
|
697 (setq literal (sgml-parse-parameter-literal 'dofunchar)))
|
|
|
698 (sgml-skip-ps)
|
|
|
699 (setq name (sgml-check-name t))
|
|
|
700 (push (cons literal name) mappings))
|
|
|
701 (sgml-add-shortref-map
|
|
|
702 (sgml-dtd-shortmaps sgml-dtd-info)
|
|
|
703 mapname
|
|
|
704 (sgml-make-shortmap mappings))))
|
|
|
705
|
|
|
706 ;;;152 short reference use declaration = MDO, "USEMAP",
|
|
|
707 ;;; [[65 ps]]+, [[153 map specification]],
|
|
|
708 ;;; ([[65 ps]]+, [[72 associated element type]])?,
|
|
|
709 ;;; [[65 ps]]*, MDC
|
|
|
710
|
|
|
711 (defun sgml-do-usemap-element (mapname)
|
|
|
712 ;; This is called from sgml-do-usemap with the mapname
|
|
|
713 (sgml-before-eltype-modification)
|
|
|
714 (loop for e in (sgml-parse-name-group) do
|
|
|
715 (setf (sgml-eltype-shortmap (sgml-lookup-eltype e sgml-dtd-info))
|
|
|
716 (if (null mapname)
|
|
|
717 'empty
|
|
|
718 mapname))))
|
|
|
719
|
|
|
720
|
|
|
721 ;;;; Parse doctype
|
|
|
722
|
|
|
723 (defun sgml-check-dtd-subset ()
|
|
|
724 (let ((sgml-parsing-dtd t)
|
|
|
725 (eref sgml-current-eref))
|
|
|
726 (while
|
|
|
727 (progn
|
|
|
728 (setq sgml-markup-start (point))
|
|
|
729 (cond
|
|
|
730 ((and (eobp) (eq sgml-current-eref eref))
|
|
|
731 nil)
|
|
|
732 ((sgml-parse-ds))
|
|
|
733 ((sgml-parse-markup-declaration 'dtd))
|
|
|
734 ((sgml-parse-delim "MS-END")))))))
|
|
|
735
|
|
|
736
|
|
|
737 ;;;; Save DTD: compute translation
|
|
|
738
|
|
|
739 (defvar sgml-translate-table nil)
|
|
|
740
|
|
|
741 (defun sgml-translate-node (node)
|
|
|
742 (assert (not (numberp node)))
|
|
|
743 (let ((tp (assq node sgml-translate-table)))
|
|
|
744 (unless tp
|
|
|
745 (setq tp (cons node (length sgml-translate-table)))
|
|
|
746 (nconc sgml-translate-table (list tp)))
|
|
|
747 (cdr tp)))
|
|
|
748
|
|
|
749 (defun sgml-translate-moves (moves)
|
|
|
750 (while moves
|
|
|
751 (sgml-translate-node (sgml-move-dest (car moves)))
|
|
|
752 (setq moves (cdr moves))))
|
|
|
753
|
|
|
754 (defun sgml-translate-model (model)
|
|
|
755 (let* ((sgml-translate-table (list (cons model 0)))
|
|
|
756 (p sgml-translate-table))
|
|
|
757 (while p
|
|
|
758 (cond ((sgml-normal-state-p (caar p))
|
|
|
759 (sgml-translate-moves (sgml-state-opts (caar p)))
|
|
|
760 (sgml-translate-moves (sgml-state-reqs (caar p))))
|
|
|
761 (t
|
|
|
762 (sgml-translate-node (sgml-&node-next (caar p)))))
|
|
|
763 (setq p (cdr p)))
|
|
|
764 sgml-translate-table))
|
|
|
765
|
|
|
766 ;;;; Save DTD: binary coding
|
|
|
767
|
|
|
768 (defvar sgml-code-token-numbers nil)
|
|
|
769 (defvar sgml-code-xlate nil)
|
|
|
770
|
|
|
771 (defsubst sgml-code-xlate (node)
|
|
|
772 ;;(let ((x (cdr (assq node sgml-code-xlate)))) (assert x) x)
|
|
|
773 (cdr (assq node sgml-code-xlate)))
|
|
|
774
|
|
|
775 (defun sgml-code-number (num)
|
|
|
776 (if (> num sgml-max-single-octet-number)
|
|
|
777 (insert (+ (lsh (- num sgml-max-single-octet-number) -8)
|
|
|
778 sgml-max-single-octet-number 1)
|
|
|
779 (logand (- num sgml-max-single-octet-number) 255))
|
|
|
780 (insert num)))
|
|
|
781
|
|
|
782 (defun sgml-code-token-number (token)
|
|
|
783 (let ((bp (assq token sgml-code-token-numbers)))
|
|
|
784 (unless bp
|
|
|
785 (setq sgml-code-token-numbers
|
|
|
786 (nconc sgml-code-token-numbers
|
|
|
787 (list (setq bp (cons token
|
|
|
788 (length sgml-code-token-numbers)))))))
|
|
|
789 (cdr bp)))
|
|
|
790
|
|
|
791 (defun sgml-code-token (token)
|
|
|
792 (sgml-code-number (sgml-code-token-number token)))
|
|
|
793
|
|
|
794 (defmacro sgml-code-sequence (loop-c &rest body)
|
|
|
795 "Produce the binary coding of a counted sequence from a list.
|
|
|
796 Syntax: (var seq) &body forms
|
|
|
797 FORMS should produce the binary coding of element in VAR."
|
|
|
798 (let ((var (car loop-c))
|
|
|
799 (seq (cadr loop-c)))
|
|
|
800 (` (let ((seq (, seq)))
|
|
|
801 (sgml-code-number (length seq))
|
|
|
802 (loop for (, var) in seq
|
|
|
803 do (,@ body))))))
|
|
|
804
|
|
|
805 (put 'sgml-code-sequence 'lisp-indent-hook 1)
|
|
|
806 (put 'sgml-code-sequence 'edbug-forms-hook '(sexp &rest form))
|
|
|
807
|
|
|
808 (defun sgml-code-sexp (sexp)
|
|
|
809 (let ((standard-output (current-buffer)))
|
|
|
810 (prin1 sexp)
|
|
|
811 (terpri)))
|
|
|
812
|
|
|
813 (defun sgml-code-tokens (l)
|
|
|
814 (sgml-code-sequence (x l)
|
|
|
815 (sgml-code-token x)))
|
|
|
816
|
|
|
817 (defsubst sgml-code-move (m)
|
|
|
818 (sgml-code-token (sgml-move-token m))
|
|
|
819 (insert (sgml-code-xlate (sgml-move-dest m))))
|
|
|
820
|
|
|
821 (defun sgml-code-model (m)
|
|
|
822 (let ((sgml-code-xlate (sgml-translate-model m)))
|
|
|
823 (sgml-code-sequence (s sgml-code-xlate) ; s is (node . number)
|
|
|
824 (setq s (car s)) ; s is node
|
|
|
825 (cond
|
|
|
826 ((sgml-normal-state-p s)
|
|
|
827 (assert (and (< (length (sgml-state-opts s)) 255)
|
|
|
828 (< (length (sgml-state-reqs s)) 256)))
|
|
|
829 (sgml-code-sequence (x (sgml-state-opts s))
|
|
|
830 (sgml-code-move x))
|
|
|
831 (sgml-code-sequence (x (sgml-state-reqs s))
|
|
|
832 (sgml-code-move x)))
|
|
|
833 (t ; s is a &-node
|
|
|
834 (insert 255) ; Tag &-node
|
|
|
835 (insert (sgml-code-xlate (sgml-&node-next s)))
|
|
|
836 (sgml-code-sequence (m (sgml-&node-dfas s))
|
|
|
837 (sgml-code-model m)))))))
|
|
|
838
|
|
|
839 (defun sgml-code-element (et)
|
|
|
840 (sgml-code-sexp (sgml-eltype-all-miscdata et))
|
|
|
841 (cond
|
|
|
842 ((not (sgml-eltype-defined et))
|
|
|
843 (insert 128))
|
|
|
844 (t
|
|
|
845 (insert (sgml-eltype-flags et))
|
|
|
846 (let ((c (sgml-eltype-model et)))
|
|
|
847 (cond ((eq c sgml-cdata) (insert 0))
|
|
|
848 ((eq c sgml-rcdata) (insert 1))
|
|
|
849 ((eq c sgml-empty) (insert 2))
|
|
|
850 ((eq c sgml-any) (insert 3))
|
|
|
851 ((null c) (insert 4))
|
|
|
852 (t
|
|
|
853 (assert (sgml-model-group-p c))
|
|
|
854 (insert 128)
|
|
|
855 (sgml-code-model c))))
|
|
|
856 (sgml-code-tokens (sgml-eltype-includes et))
|
|
|
857 (sgml-code-tokens (sgml-eltype-excludes et)))))
|
|
|
858
|
|
|
859
|
|
|
860 (defun sgml-code-dtd (dtd)
|
|
|
861 "Produce the binary coding of the current DTD into the current buffer."
|
|
|
862 (sgml-code-sexp (sgml-dtd-dependencies dtd))
|
|
|
863 (sgml-code-sexp (sgml-dtd-parameters dtd))
|
|
|
864 (sgml-code-sexp (sgml-dtd-doctype dtd))
|
|
|
865 (let ((done 0) ; count written elements
|
|
|
866 tot)
|
|
|
867 (setq sgml-code-token-numbers nil)
|
|
|
868 (sgml-code-token-number sgml-pcdata-token) ; Make #PCDATA token 0
|
|
|
869 (sgml-map-eltypes ; Assign numbers to all tokens
|
|
|
870 (function (lambda (et)
|
|
|
871 (sgml-code-token-number (sgml-eltype-token et))))
|
|
|
872 dtd nil t)
|
|
|
873 (setq tot (length sgml-code-token-numbers))
|
|
|
874 ;; Produce the counted sequence of element type names
|
|
|
875 (sgml-code-sequence (pair (cdr sgml-code-token-numbers))
|
|
|
876 (sgml-code-sexp (sgml-eltype-name (car pair))))
|
|
|
877 ;; Produce the counted sequence of element types
|
|
|
878 (sgml-code-sequence (pair (cdr sgml-code-token-numbers))
|
|
|
879 (setq done (1+ done))
|
|
|
880 (sgml-code-element (car pair))
|
|
|
881 (sgml-lazy-message "Saving DTD %d%% done" (/ (* 100 done) tot)))
|
|
|
882 (sgml-code-sexp (sgml-dtd-entities dtd))
|
|
|
883 (sgml-code-sexp (sgml-dtd-shortmaps dtd))
|
|
|
884 (sgml-code-sexp (sgml-dtd-notations dtd))))
|
|
|
885
|
|
|
886
|
|
|
887 ;;;; Save DTD
|
|
|
888
|
|
|
889 (defun sgml-save-dtd (file)
|
|
|
890 "Save the parsed dtd on FILE."
|
|
|
891 (interactive
|
|
|
892 (let* ((tem (expand-file-name
|
|
|
893 (or sgml-default-dtd-file
|
|
|
894 (sgml-default-dtd-file))))
|
|
|
895 (dir (file-name-directory tem))
|
|
|
896 (nam (file-name-nondirectory tem)))
|
|
|
897 (list
|
|
|
898 (read-file-name "Save DTD in: " dir tem nil nam))))
|
|
|
899 (setq file (expand-file-name file))
|
|
|
900 (when (equal file (buffer-file-name))
|
|
|
901 (error "Would clobber current file"))
|
|
|
902 (sgml-need-dtd)
|
|
|
903 (sgml-push-to-entity (sgml-make-entity "#SAVE" nil ""))
|
|
|
904 (sgml-write-dtd sgml-dtd-info file)
|
|
|
905 (sgml-pop-entity)
|
|
|
906 (setq sgml-default-dtd-file
|
|
|
907 (if (equal (expand-file-name default-directory)
|
|
|
908 (file-name-directory file))
|
|
|
909 (file-name-nondirectory file)
|
|
|
910 file))
|
|
|
911 (setq sgml-loaded-dtd file))
|
|
|
912
|
|
|
913 (defun sgml-write-dtd (dtd file)
|
|
|
914 "Save the parsed dtd on FILE.
|
|
|
915 Construct the binary coded DTD (bdtd) in the current buffer."
|
|
|
916 (insert
|
|
|
917 ";;; This file was created by psgml on " (current-time-string) "\n"
|
|
|
918 "(sgml-saved-dtd-version 6)\n")
|
|
|
919 (sgml-code-dtd dtd)
|
|
|
920 (setq file-type 1)
|
|
|
921 (write-region (point-min) (point-max) file))
|
|
|
922
|
|
|
923
|
|
|
924 ;;; psgml-dtd.el ends here
|
