This bug report will be sent to the XEmacs Development Team,
not to your local site managers!!
Please write in English, because the XEmacs maintainers do not have
translators to read other languages for them.
Please describe as succinctly as possible:
- What happened.
- What you thought should have happened.
- Precisely what you were doing at the time.
Please also include any C or lisp back-traces that you may have.
================================================================
Dear Bug Team!
I've been re-formatting some HTML document (with
indent-region-or-balanced-expression), and since it took forever (as
usual:-( ), I changed my mind and pressed C-g. XEmacs normally
responds well when I do that, but this time I got an internal error:
(1) (file/alert) Cannot write backup file; backing up in ~/%backup%~
(2) (error/warning) Error in post-gc-hook: (quit nil)
Backtrace follows:
# bind (inhibit-quit)
# (unwind-protect ...)
# (unwind-protect ...)
# (catch #<INTERNAL OBJECT (XEmacs bug?) (opaque, size=0) 0x83cf610> ...)
# (unwind-protect ...)
# (unwind-protect ...)
# bind (args)
#<compiled-function (&rest args) "...(28)" [result args reverse cons] 4
640435>((quote progn) (append (if move (\` ((forward-char (\, (length ds)))))) (if (not
(eq move (quote check))) (quote (t)))))
(bq-list* (quote progn) (append (if move (\` ((forward-char (\, (length ds)))))) (if
(not (eq move (quote check))) (quote (t)))))
(cons (bq-list* (quote progn) (append (if move (\` ((forward-char (\, (length ds))))))
(if (not (eq move (quote check))) (quote (t))))) (if (eq move (quote check)) (\`
((sgml-delimiter-parse-error (\, delim))))))
(cons (bq-list* (quote and) (append (loop for i from 0 below (length ds) collect (\` (eq
(\, (aref ds i)) (sgml-following-char (\, (+ i offset)))))) (list (bq-list* (quote or)
(loop for c in context collect (cond ((eq c (quote nmstart)) (\` (sgml-startnm-char (or
(sgml-following-char (\, (length ds))) 0)))) ((eq c (quote stagc)) (\` (and
sgml-current-shorttag (sgml-is-delim "TAGC" nil nil (\, (length ds)))))) ((eq c
(quote digit)) (\` (memq (sgml-following-char (\, (length ds))) (quote (?0 ?1 ?2 ?3 ?4 ?5
?6 ?7 ?8 ?9))))) ((stringp c) (\` (sgml-is-delim (\, c) nil nil (\, (length ds))))) ((eq c
t)) (t (error "Context type: %s" c)))))))) (cons (bq-list* (quote progn) (append
(if move (\` ((forward-char (\, (length ds)))))) (if (not (eq move (quote check))) (quote
(t))))) (if (eq move (quote check)) (\` ((sgml-delimiter-parse-error (\, delim)))))))
(cons (quote if) (cons (bq-list* (quote and) (append (loop for i from 0 below (length
ds) collect (\` (eq (\, (aref ds i)) (sgml-following-char (\, (+ i offset)))))) (list
(bq-list* (quote or) (loop for c in context collect (cond ((eq c (quote nmstart)) (\`
(sgml-startnm-char (or (sgml-following-char (\, (length ds))) 0)))) ((eq c (quote stagc))
(\` (and sgml-current-shorttag (sgml-is-delim "TAGC" nil nil (\, (length
ds)))))) ((eq c (quote digit)) (\` (memq (sgml-following-char (\, (length ds))) (quote (?0
?1 ?2 ?3 ?4 ?5 ?6 ?7 ?8 ?9))))) ((stringp c) (\` (sgml-is-delim (\, c) nil nil (\, (length
ds))))) ((eq c t)) (t (error "Context type: %s" c)))))))) (cons (bq-list* (quote
progn) (append (if move (\` ((forward-char (\, (length ds)))))) (if (not (eq move (quote
check))) (quote (t))))) (if (eq move (quote check)) (\` ((sgml-delimiter-parse-error (\,
delim))))))))
(bq-list* (quote if) (bq-list* (quote and) (append (loop for i from 0 below (length ds)
collect (\` (eq (\, (aref ds i)) (sgml-following-char (\, (+ i offset)))))) (list
(bq-list* (quote or) (loop for c in context collect (cond ((eq c (quote nmstart)) (\`
(sgml-startnm-char (or (sgml-following-char (\, (length ds))) 0)))) ((eq c (quote stagc))
(\` (and sgml-current-shorttag (sgml-is-delim "TAGC" nil nil (\, (length
ds)))))) ((eq c (quote digit)) (\` (memq (sgml-following-char (\, (length ds))) (quote (?0
?1 ?2 ?3 ?4 ?5 ?6 ?7 ?8 ?9))))) ((stringp c) (\` (sgml-is-delim (\, c) nil nil (\, (length
ds))))) ((eq c t)) (t (error "Context type: %s" c)))))))) (bq-list* (quote
progn) (append (if move (\` ((forward-char (\, (length ds)))))) (if (not (eq move (quote
check))) (quote (t))))) (if (eq move (quote check)) (\` ((sgml-delimiter-parse-error (\,
delim))))))
(\` (if (and (\,@ (loop for i from 0 below (length ds) collect (\` (eq (\, (aref ds i))
(sgml-following-char (\, (+ i offset))))))) (or (\,@ (loop for c in context collect (cond
((eq c (quote nmstart)) (\` (sgml-startnm-char (or (sgml-following-char (\, (length ds)))
0)))) ((eq c (quote stagc)) (\` (and sgml-current-shorttag (sgml-is-delim "TAGC"
nil nil (\, (length ds)))))) ((eq c (quote digit)) (\` (memq (sgml-following-char (\,
(length ds))) (quote (?0 ?1 ?2 ?3 ?4 ?5 ?6 ?7 ?8 ?9))))) ((stringp c) (\` (sgml-is-delim
(\, c) nil nil (\, (length ds))))) ((eq c t)) (t (error "Context type: %s"
c))))))) (progn (\,@ (if move (\` ((forward-char (\, (length ds))))))) (\,@ (if (not (eq
move (quote check))) (quote (t))))) (\,@ (if (eq move (quote check)) (\`
((sgml-delimiter-parse-error (\, delim))))))))
# bind (ds)
(let ((ds (sgml-get-delim-string delim))) (assert ds) (cond ((eq context (quote gi))
(setq context (quote (nmstart stagc)))) ((eq context (quote com)) (setq context (quote
("COM" "MDC")))) ((null context) (setq context (quote (t)))) ((not
(listp context)) (setq context (list context)))) (\` (if (and (\,@ (loop for i from 0
below (length ds) collect (\` (eq (\, (aref ds i)) (sgml-following-char (\, (+ i
offset))))))) (or (\,@ (loop for c in context collect (cond ((eq c (quote nmstart)) (\`
(sgml-startnm-char (or (sgml-following-char (\, (length ds))) 0)))) ((eq c (quote stagc))
(\` (and sgml-current-shorttag (sgml-is-delim "TAGC" nil nil (\, (length
ds)))))) ((eq c (quote digit)) (\` (memq (sgml-following-char (\, (length ds))) (quote (?0
?1 ?2 ?3 ?4 ?5 ?6 ?7 ?8 ?9))))) ((stringp c) (\` (sgml-is-delim (\, c) nil nil (\, (length
ds))))) ((eq c t)) (t (error "Context type: %s" c))))))) (progn (\,@ (if move
(\` ((forward-char (\, (length ds))))))) (\,@ (if (not (eq move (quote check))) (quote
(t))))) (\,@ (if (eq move (quote check)) (\` ((sgml-delimiter-parse-error (\,
delim)))))))))
# bind (offset move context delim)
(lambda (delim &optional context move offset) "Macro for matching
delimiters.\nSyntax: DELIM &optional CONTEXT MOVE\nwhere DELIM is the delimiter name
(string or symbol), \nCONTEXT the contextual constraint, and\nMOVE is `nil',
`move' or `check'.\n\nTest if the text following point in current buffer matches
the SGML\ndelimiter DELIM. Also check the characters after the delimiter for\nCONTEXT.
Applicable values for CONTEXT is \n`gi' -- name start or TAGC if SHORTTAG
YES,\n`com' -- if COM or MDC,\n`nmstart' -- name start character, \n`stagc' --
TAGC if SHORTTAG YES,\n`digit' -- any Digit,\nstring -- delimiter with that
name,\nlist -- any of the contextual constraints in the list." (or offset (setq
offset 0)) (setq delim (upcase (format "%s" delim))) (let ((ds
(sgml-get-delim-string delim))) (assert ds) (cond ((eq context (quote gi)) (setq context
(quote (nmstart stagc)))) ((eq context (quote com)) (setq context (quote ("COM"
"MDC")))) ((null context) (setq context (quote (t)))) ((not (listp context))
(setq context (list context)))) (\` (if (and (\,@ (loop for i from 0 below (length ds)
collect (\` (eq (\, (aref ds i)) (sgml-following-char (\, (+ i offset))))))) (or (\,@
(loop for c in context collect (cond ((eq c (quote nmstart)) (\` (sgml-startnm-char (or
(sgml-following-char (\, (length ds))) 0)))) ((eq c (quote stagc)) (\` (and
sgml-current-shorttag (sgml-is-delim "TAGC" nil nil (\, (length ds)))))) ((eq c
(quote digit)) (\` (memq (sgml-following-char (\, (length ds))) (quote (?0 ?1 ?2 ?3 ?4 ?5
?6 ?7 ?8 ?9))))) ((stringp c) (\` (sgml-is-delim (\, c) nil nil (\, (length ds))))) ((eq c
t)) (t (error "Context type: %s" c))))))) (progn (\,@ (if move (\`
((forward-char (\, (length ds))))))) (\,@ (if (not (eq move (quote check))) (quote (t)))))
(\,@ (if (eq move (quote check)) (\` ((sgml-delimiter-parse-error (\,
delim))))))))))("RNI" nil move)
(sgml-is-delim "RNI" nil move)
(sgml-parse-delim "RNI")
(if (sgml-parse-delim "RNI") (sgml-check-token "DEFAULT"))
(sgml-parse-rni "DEFAULT")
(or (sgml-parse-rni "DEFAULT") (setq name (sgml-check-name t)))
(cond ((sgml-parse-delim "PERO") (sgml-skip-ps) (setq name (sgml-check-name
t)) (setq dest (sgml-dtd-parameters sgml-dtd-info))) (t (or (sgml-parse-rni
"DEFAULT") (setq name (sgml-check-name t))) (setq dest (sgml-dtd-entities
sgml-dtd-info))))
# bind (extid text notation type dest name)
(let (name dest (type (quote text)) (notation nil) text extid) (cond ((sgml-parse-delim
"PERO") (sgml-skip-ps) (setq name (sgml-check-name t)) (setq dest
(sgml-dtd-parameters sgml-dtd-info))) (t (or (sgml-parse-rni "DEFAULT") (setq
name (sgml-check-name t))) (setq dest (sgml-dtd-entities sgml-dtd-info)))) (sgml-skip-ps)
(setq extid (sgml-parse-external)) (setq text (cond (extid (sgml-skip-ps) (let ((tn
(sgml-parse-entity-type))) (setq type (or (car tn) (quote text))) (unless (eq (cdr tn)
"") (setq notation (cdr tn)))) extid) ((sgml-startnm-char-next) (let ((token
(intern (sgml-check-case (sgml-check-name))))) (sgml-skip-ps) (when (and sgml-xml-p (memq
token (quote (cdata sdata pi starttag endtag ms md)))) (sgml-error "XML forbids %s
entities." (upcase (symbol-name token)))) (cond ((memq token (quote (CDATA SDATA)))
(setq type token) (sgml-check-parameter-literal)) ((eq token (quote PI)) (concat
"<?" (sgml-check-parameter-literal) ">")) ((eq token (quote
STARTTAG)) (sgml-start-tag-of (sgml-check-parameter-literal))) ((eq token (quote ENDTAG))
(sgml-end-tag-of (sgml-check-parameter-literal))) ((eq token (quote MS)) (concat
"<![" (sgml-check-parameter-literal) "]]>")) ((eq token (quote
MD)) (concat "<!" (sgml-check-parameter-literal) ">")))))
((sgml-check-parameter-literal)))) (when dest (sgml-entity-declare name dest type text
notation)))
sgml-declare-entity()
funcall(sgml-declare-entity)
(cond ((eq option (quote ignore)) (sgml-skip-upto-mdc)) (rut (sgml-skip-ps) (funcall
(cdr rut))) (t (sgml-parse-error "Illegal markup declaration %s" tok)))
# bind (rut tok)
(let* ((tok (sgml-parse-nametoken)) (rut (assoc (sgml-check-case tok)
sgml-markup-declaration-table))) (when (and (not (memq option (quote (prolog ignore))))
(member tok (quote ("SGML" "DOCTYPE")))) (sgml-error "%s
declaration is only valid in prolog" tok)) (when (and (not (memq option (quote (dtd
ignore)))) (member tok (quote ("ELEMENT" "ENTITY" "ATTLIST"
"NOTATION" "SHORTREF")))) (sgml-error "%s declaration is only
valid in doctype" tok)) (cond ((eq option (quote ignore)) (sgml-skip-upto-mdc)) (rut
(sgml-skip-ps) (funcall (cdr rut))) (t (sgml-parse-error "Illegal markup declaration
%s" tok))))
(cond ((sgml-startnm-char-next) (setq sgml-markup-type nil) (let* ((tok
(sgml-parse-nametoken)) (rut (assoc (sgml-check-case tok) sgml-markup-declaration-table)))
(when (and (not (memq option (quote (prolog ignore)))) (member tok (quote
("SGML" "DOCTYPE")))) (sgml-error "%s declaration is only valid
in prolog" tok)) (when (and (not (memq option (quote (dtd ignore)))) (member tok
(quote ("ELEMENT" "ENTITY" "ATTLIST" "NOTATION"
"SHORTREF")))) (sgml-error "%s declaration is only valid in doctype"
tok)) (cond ((eq option (quote ignore)) (sgml-skip-upto-mdc)) (rut (sgml-skip-ps) (funcall
(cdr rut))) (t (sgml-parse-error "Illegal markup declaration %s" tok))))) (t
(setq sgml-markup-type (quote comment))))
(cond ((and sgml-xml-p (sgml-parse-xml-comment))) ((sgml-parse-delim "MDO"
(nmstart "COM" "MDC")) (cond ((sgml-startnm-char-next) (setq
sgml-markup-type nil) (let* ((tok (sgml-parse-nametoken)) (rut (assoc (sgml-check-case
tok) sgml-markup-declaration-table))) (when (and (not (memq option (quote (prolog
ignore)))) (member tok (quote ("SGML" "DOCTYPE")))) (sgml-error
"%s declaration is only valid in prolog" tok)) (when (and (not (memq option
(quote (dtd ignore)))) (member tok (quote ("ELEMENT" "ENTITY"
"ATTLIST" "NOTATION" "SHORTREF")))) (sgml-error "%s
declaration is only valid in doctype" tok)) (cond ((eq option (quote ignore))
(sgml-skip-upto-mdc)) (rut (sgml-skip-ps) (funcall (cdr rut))) (t (sgml-parse-error
"Illegal markup declaration %s" tok))))) (t (setq sgml-markup-type (quote
comment)))) (sgml-skip-ps) (sgml-check-delim "MDC") (unless (eq option (quote
ignore)) (when sgml-markup-type (sgml-set-markup-type sgml-markup-type))) t)
((sgml-parse-delim "MS-START") (sgml-do-marked-section)))
# bind (option)
sgml-parse-markup-declaration(dtd)
(cond ((and (eobp) (eq sgml-current-eref eref)) nil) ((sgml-parse-ds))
((sgml-parse-markup-declaration (quote dtd))) ((sgml-parse-delim "MS-END")))
(progn (setq sgml-markup-start (point)) (cond ((and (eobp) (eq sgml-current-eref eref))
nil) ((sgml-parse-ds)) ((sgml-parse-markup-declaration (quote dtd))) ((sgml-parse-delim
"MS-END"))))
(while (progn (setq sgml-markup-start (point)) (cond ((and (eobp) (eq sgml-current-eref
eref)) nil) ((sgml-parse-ds)) ((sgml-parse-markup-declaration (quote dtd)))
((sgml-parse-delim "MS-END")))))
# bind (eref sgml-parsing-dtd)
(let ((sgml-parsing-dtd t) (eref sgml-current-eref)) (while (progn (setq
sgml-markup-start (point)) (cond ((and (eobp) (eq sgml-current-eref eref)) nil)
((sgml-parse-ds)) ((sgml-parse-markup-declaration (quote dtd))) ((sgml-parse-delim
"MS-END"))))))
sgml-check-dtd-subset()
(cond (external (let ((decl (and (car external) (sgml-catalog-lookup sgml-catalog-files
nil (quote dtddecl) (sgml-canonize-pubid (car external)))))) (if decl (setq
sgml-declaration decl))) (sgml-push-to-entity (sgml-make-entity docname (quote dtd)
external)) (sgml-check-dtd-subset) (sgml-check-end-of-entity "DTD subset")
(sgml-pop-entity)))
# bind (sgml-parsing-dtd)
(let ((sgml-parsing-dtd t)) (setq sgml-no-elements 0) (setq sgml-dtd-info (sgml-make-dtd
docname)) (sgml-skip-ps) (cond ((sgml-parse-delim "DSO") (let ((original-buffer
(current-buffer))) (sgml-check-dtd-subset) (if (eq (current-buffer) original-buffer)
(sgml-check-delim "DSC") (sgml-parse-error "Illegal character '%c'
in doctype declaration" (following-char)))))) (cond (external (let ((decl (and (car
external) (sgml-catalog-lookup sgml-catalog-files nil (quote dtddecl) (sgml-canonize-pubid
(car external)))))) (if decl (setq sgml-declaration decl))) (sgml-push-to-entity
(sgml-make-entity docname (quote dtd) external)) (sgml-check-dtd-subset)
(sgml-check-end-of-entity "DTD subset") (sgml-pop-entity)))
(sgml-set-initial-state sgml-dtd-info) (run-hooks (quote sgml-doctype-parsed-hook)))
# bind (external docname)
sgml-setup-doctype("HTML" ("-//W3C//DTD HTML 4.0 Transitional//EN"
"http://www.w3.org/TR/REC-html40/loose.dtd" .
"/usr/local/apache/htdocs/german/bjokes/ar/"))
# bind (sgml-markup-start)
(let (sgml-markup-start) (message "Parsing doctype...") (sgml-setup-doctype
(sgml-check-name) (sgml-parse-external)) (message "Parsing doctype...done"))
(cond (sgml-dtd-info (sgml-skip-upto-mdc)) (t (let (sgml-markup-start) (message
"Parsing doctype...") (sgml-setup-doctype (sgml-check-name)
(sgml-parse-external)) (message "Parsing doctype...done"))))
sgml-do-doctype()
funcall(sgml-do-doctype)
(cond ((eq option (quote ignore)) (sgml-skip-upto-mdc)) (rut (sgml-skip-ps) (funcall
(cdr rut))) (t (sgml-parse-error "Illegal markup declaration %s" tok)))
# bind (rut tok)
(let* ((tok (sgml-parse-nametoken)) (rut (assoc (sgml-check-case tok)
sgml-markup-declaration-table))) (when (and (not (memq option (quote (prolog ignore))))
(member tok (quote ("SGML" "DOCTYPE")))) (sgml-error "%s
declaration is only valid in prolog" tok)) (when (and (not (memq option (quote (dtd
ignore)))) (member tok (quote ("ELEMENT" "ENTITY" "ATTLIST"
"NOTATION" "SHORTREF")))) (sgml-error "%s declaration is only
valid in doctype" tok)) (cond ((eq option (quote ignore)) (sgml-skip-upto-mdc)) (rut
(sgml-skip-ps) (funcall (cdr rut))) (t (sgml-parse-error "Illegal markup declaration
%s" tok))))
(cond ((sgml-startnm-char-next) (setq sgml-markup-type nil) (let* ((tok
(sgml-parse-nametoken)) (rut (assoc (sgml-check-case tok) sgml-markup-declaration-table)))
(when (and (not (memq option (quote (prolog ignore)))) (member tok (quote
("SGML" "DOCTYPE")))) (sgml-error "%s declaration is only valid
in prolog" tok)) (when (and (not (memq option (quote (dtd ignore)))) (member tok
(quote ("ELEMENT" "ENTITY" "ATTLIST" "NOTATION"
"SHORTREF")))) (sgml-error "%s declaration is only valid in doctype"
tok)) (cond ((eq option (quote ignore)) (sgml-skip-upto-mdc)) (rut (sgml-skip-ps) (funcall
(cdr rut))) (t (sgml-parse-error "Illegal markup declaration %s" tok))))) (t
(setq sgml-markup-type (quote comment))))
(cond ((and sgml-xml-p (sgml-parse-xml-comment))) ((sgml-parse-delim "MDO"
(nmstart "COM" "MDC")) (cond ((sgml-startnm-char-next) (setq
sgml-markup-type nil) (let* ((tok (sgml-parse-nametoken)) (rut (assoc (sgml-check-case
tok) sgml-markup-declaration-table))) (when (and (not (memq option (quote (prolog
ignore)))) (member tok (quote ("SGML" "DOCTYPE")))) (sgml-error
"%s declaration is only valid in prolog" tok)) (when (and (not (memq option
(quote (dtd ignore)))) (member tok (quote ("ELEMENT" "ENTITY"
"ATTLIST" "NOTATION" "SHORTREF")))) (sgml-error "%s
declaration is only valid in doctype" tok)) (cond ((eq option (quote ignore))
(sgml-skip-upto-mdc)) (rut (sgml-skip-ps) (funcall (cdr rut))) (t (sgml-parse-error
"Illegal markup declaration %s" tok))))) (t (setq sgml-markup-type (quote
comment)))) (sgml-skip-ps) (sgml-check-delim "MDC") (unless (eq option (quote
ignore)) (when sgml-markup-type (sgml-set-markup-type sgml-markup-type))) t)
((sgml-parse-delim "MS-START") (sgml-do-marked-section)))
# bind (option)
sgml-parse-markup-declaration(prolog)
(and (sgml-parse-markup-declaration (quote prolog)) (null sgml-dtd-info))
(or (sgml-parse-s) (sgml-parse-processing-instruction) (and
(sgml-parse-markup-declaration (quote prolog)) (null sgml-dtd-info)))
(progn (setq sgml-markup-start (point)) (or (sgml-parse-s)
(sgml-parse-processing-instruction) (and (sgml-parse-markup-declaration (quote prolog))
(null sgml-dtd-info))))
(while (progn (setq sgml-markup-start (point)) (or (sgml-parse-s)
(sgml-parse-processing-instruction) (and (sgml-parse-markup-declaration (quote prolog))
(null sgml-dtd-info)))))
(progn (while (progn (setq sgml-markup-start (point)) (or (sgml-parse-s)
(sgml-parse-processing-instruction) (and (sgml-parse-markup-declaration (quote prolog))
(null sgml-dtd-info))))) (unless sgml-dtd-info (let ((docname (or
sgml-default-doctype-name (if (sgml-parse-delim "STAGO" gi)
(sgml-parse-name))))) (when docname (sgml-setup-doctype docname (quote (nil)))))))
# (unwind-protect ...)
(unwind-protect (progn (while (progn (setq sgml-markup-start (point)) (or (sgml-parse-s)
(sgml-parse-processing-instruction) (and (sgml-parse-markup-declaration (quote prolog))
(null sgml-dtd-info))))) (unless sgml-dtd-info (let ((docname (or
sgml-default-doctype-name (if (sgml-parse-delim "STAGO" gi)
(sgml-parse-name))))) (when docname (sgml-setup-doctype docname (quote (nil))))))) (setq
sgml-last-buffer (current-buffer)) (set-buffer cb) (set-syntax-table normal-syntax-table)
(set-buffer-modified-p buffer-modified) (sgml-debug "Restoring buffer mod: %s"
buffer-modified))
# bind (buffer-modified cb normal-syntax-table)
(let ((normal-syntax-table (syntax-table)) (cb (current-buffer)) (buffer-modified
(buffer-modified-p))) (set-syntax-table (if sgml-xml-p xml-parser-syntax
sgml-parser-syntax)) (unwind-protect (progn (while (progn (setq sgml-markup-start (point))
(or (sgml-parse-s) (sgml-parse-processing-instruction) (and (sgml-parse-markup-declaration
(quote prolog)) (null sgml-dtd-info))))) (unless sgml-dtd-info (let ((docname (or
sgml-default-doctype-name (if (sgml-parse-delim "STAGO" gi)
(sgml-parse-name))))) (when docname (sgml-setup-doctype docname (quote (nil))))))) (setq
sgml-last-buffer (current-buffer)) (set-buffer cb) (set-syntax-table normal-syntax-table)
(set-buffer-modified-p buffer-modified) (sgml-debug "Restoring buffer mod: %s"
buffer-modified)))
(sgml-with-parser-syntax-ro (while (progn (setq sgml-markup-start (point)) (or
(sgml-parse-s) (sgml-parse-processing-instruction) (and (sgml-parse-markup-declaration
(quote prolog)) (null sgml-dtd-info))))) (unless sgml-dtd-info (let ((docname (or
sgml-default-doctype-name (if (sgml-parse-delim "STAGO" gi)
(sgml-parse-name))))) (when docname (sgml-setup-doctype docname (quote (nil)))))))
sgml-parse-prolog()
# (unwind-protect ...)
(save-excursion (sgml-parse-prolog))
(cond ((or sgml-parent-document sgml-doctype) (let ((dtd (save-excursion (set-buffer
(find-file-noselect (if (consp sgml-parent-document) (car sgml-parent-document) (or
sgml-doctype sgml-parent-document)))) (sgml-need-dtd) (sgml-pstate-dtd
sgml-buffer-parse-state)))) (sgml-set-initial-state dtd) (when (consp
sgml-parent-document) (sgml-modify-dtd (cdr sgml-parent-document))))) (t (save-excursion
(sgml-parse-prolog))))
sgml-load-doctype()
(if sgml-default-dtd-file (sgml-load-dtd sgml-default-dtd-file) (sgml-load-doctype))
(progn (add-hook (quote pre-command-hook) (quote sgml-reset-log)) (make-local-variable
(quote sgml-auto-fill-inhibit-function)) (setq sgml-auto-fill-inhibit-function (function
sgml-in-prolog-p)) (if sgml-default-dtd-file (sgml-load-dtd sgml-default-dtd-file)
(sgml-load-doctype)))
(if (null sgml-buffer-parse-state) (progn (add-hook (quote pre-command-hook) (quote
sgml-reset-log)) (make-local-variable (quote sgml-auto-fill-inhibit-function)) (setq
sgml-auto-fill-inhibit-function (function sgml-in-prolog-p)) (if sgml-default-dtd-file
(sgml-load-dtd sgml-default-dtd-file) (sgml-load-doctype))))
(when (null sgml-buffer-parse-state) (add-hook (quote pre-command-hook) (quote
sgml-reset-log)) (make-local-variable (quote sgml-auto-fill-inhibit-function)) (setq
sgml-auto-fill-inhibit-function (function sgml-in-prolog-p)) (if sgml-default-dtd-file
(sgml-load-dtd sgml-default-dtd-file) (sgml-load-doctype)))
sgml-need-dtd()
# bind (quiet extra-cond sgml-goal)
sgml-parse-to(758)
# (unwind-protect ...)
(save-excursion (sgml-parse-to (1+ pos)) (let ((u sgml-top-tree)) (while (cond ((and
(sgml-tree-next u) (>= pos (sgml-element-start (sgml-tree-next u)))) (setq u
(sgml-tree-next u))) ((and (sgml-tree-etag-epos u) (>= pos (sgml-tree-end u))) (setq u
(sgml-tree-parent u)) nil) ((and (sgml-tree-content u) (>= pos (sgml-element-start
(sgml-tree-content u)))) (setq u (sgml-tree-content u))))) u))
# bind (pos)
sgml-find-element-of(757)
(if (eobp) (sgml-find-context-of (point)) (sgml-find-element-of (point)))
# (catch parse-error ...)
(catch sgml-throw-on-error (if (eobp) (sgml-find-context-of (point))
(sgml-find-element-of (point))))
# bind (sgml-throw-on-error)
(let ((sgml-throw-on-error (quote parse-error))) (catch sgml-throw-on-error (if (eobp)
(sgml-find-context-of (point)) (sgml-find-element-of (point)))))
(setq element (let ((sgml-throw-on-error (quote parse-error))) (catch
sgml-throw-on-error (if (eobp) (sgml-find-context-of (point)) (sgml-find-element-of
(point))))))
(if (or col element) nil (setq element (let ((sgml-throw-on-error (quote parse-error)))
(catch sgml-throw-on-error (if (eobp) (sgml-find-context-of (point)) (sgml-find-element-of
(point)))))))
(unless (or col element) (setq element (let ((sgml-throw-on-error (quote parse-error)))
(catch sgml-throw-on-error (if (eobp) (sgml-find-context-of (point)) (sgml-find-element-of
(point)))))))
# bind (here)
(let ((here (point-marker))) (back-to-indentation) (unless (or col element) (setq
element (let ((sgml-throw-on-error (quote parse-error))) (catch sgml-throw-on-error (if
(eobp) (sgml-find-context-of (point)) (sgml-find-element-of (point))))))) (when (eq
element sgml-top-tree) (setq element nil) (goto-char here)) (when element
(sgml-with-parser-syntax (let ((stag (sgml-is-start-tag)) (etag (sgml-is-end-tag))) (cond
((and (> (point) (sgml-element-start element)) (< (point) (sgml-element-stag-end
element))) (setq col (+ (save-excursion (goto-char (sgml-element-start element))
(current-column)) (length (sgml-element-gi element)) 2))) ((and (not (member*
(sgml-element-gi (if (or stag etag) (sgml-element-parent element) element))
sgml-inhibit-indent-tags :test (function equalp))) (or sgml-indent-data (not
(sgml-element-data-p (if stag (sgml-element-parent element) element)))) (setq col (*
sgml-indent-step (+ (if (or stag etag) -1 0) (sgml-element-level element)))))))))) (when
(and col (/= col (current-column))) (beginning-of-line 1) (delete-horizontal-space)
(indent-to col)) (when (< (point) here) (goto-char here)) col)
(if sgml-indent-step (let ((here (point-marker))) (back-to-indentation) (unless (or col
element) (setq element (let ((sgml-throw-on-error (quote parse-error))) (catch
sgml-throw-on-error (if (eobp) (sgml-find-context-of (point)) (sgml-find-element-of
(point))))))) (when (eq element sgml-top-tree) (setq element nil) (goto-char here)) (when
element (sgml-with-parser-syntax (let ((stag (sgml-is-start-tag)) (etag
(sgml-is-end-tag))) (cond ((and (> (point) (sgml-element-start element)) (< (point)
(sgml-element-stag-end element))) (setq col (+ (save-excursion (goto-char
(sgml-element-start element)) (current-column)) (length (sgml-element-gi element)) 2)))
((and (not (member* (sgml-element-gi (if (or stag etag) (sgml-element-parent element)
element)) sgml-inhibit-indent-tags :test (function equalp))) (or sgml-indent-data (not
(sgml-element-data-p (if stag (sgml-element-parent element) element)))) (setq col (*
sgml-indent-step (+ (if (or stag etag) -1 0) (sgml-element-level element)))))))))) (when
(and col (/= col (current-column))) (beginning-of-line 1) (delete-horizontal-space)
(indent-to col)) (when (< (point) here) (goto-char here)) col))
(when sgml-indent-step (let ((here (point-marker))) (back-to-indentation) (unless (or
col element) (setq element (let ((sgml-throw-on-error (quote parse-error))) (catch
sgml-throw-on-error (if (eobp) (sgml-find-context-of (point)) (sgml-find-element-of
(point))))))) (when (eq element sgml-top-tree) (setq element nil) (goto-char here)) (when
element (sgml-with-parser-syntax (let ((stag (sgml-is-start-tag)) (etag
(sgml-is-end-tag))) (cond ((and (> (point) (sgml-element-start element)) (< (point)
(sgml-element-stag-end element))) (setq col (+ (save-excursion (goto-char
(sgml-element-start element)) (current-column)) (length (sgml-element-gi element)) 2)))
((and (not (member* (sgml-element-gi (if (or stag etag) (sgml-element-parent element)
element)) sgml-inhibit-indent-tags :test (function equalp))) (or sgml-indent-data (not
(sgml-element-data-p (if stag (sgml-element-parent element) element)))) (setq col (*
sgml-indent-step (+ (if (or stag etag) -1 0) (sgml-element-level element)))))))))) (when
(and col (/= col (current-column))) (beginning-of-line 1) (delete-horizontal-space)
(indent-to col)) (when (< (point) here) (goto-char here)) col))
# bind (element col)
sgml-indent-line()
funcall(sgml-indent-line)
(if (null sgml-indent-step) (insert-tab) (funcall indent-line-function))
(lambda nil "Indent line in proper way for current major mode." (interactive)
(if (null sgml-indent-step) (insert-tab) (funcall indent-line-function)))()
call-interactively(sgml-indent-or-tab)
# (condition-case ... . error)
# (catch top-level ...)
================================================================
System Info to help track down your bug:
---------------------------------------
uname -a: Linux linux 2.4.0 #3 Sun Jan 28 20:49:46 GMT 2001 i686 unknown
./configure '--with-mule' '--with-x11' '--with-toolbars=yes'
XEmacs 21.5-b7 "broccoflower" configured for `i686-pc-linux'.
Compilation / Installation:
Source code location: /usr/local/cvs.src/xemacs/xemacs-21.5
Installation prefix: /usr/local
Operating system description file: `s/linux.h'
Machine description file: `m/intel386.h'
Compiler: gcc -g -O3 -Wall -Wno-switch -Winline
-Wmissing-prototypes -Wsign-compare -Wshadow
Relocating allocator for buffers: no
GNU version of malloc: yes
- Using Doug Lea's new malloc from the GNU C Library.
Window System:
Compiling in support for the X window system:
- X Windows headers location: /usr/X11/include
- X Windows libraries location: /usr/X11/lib
- Handling WM_COMMAND properly.
Using Lucid menubars.
Using Lucid scrollbars.
TTY:
Compiling in support for ncurses.
Compiling in support for GPM (General Purpose Mouse).
Images:
Compiling in support for GIF images (builtin).
Compiling in support for XPM images.
Compiling in support for PNG images.
Compiling in support for JPEG images.
Compiling in support for TIFF images.
Sound:
Compiling in support for sound (native).
Compiling in support for ESD (Enlightened Sound Daemon).
Databases:
Compiling in support for Berkeley database.
Compiling in support for GNU DBM.
Internationalization:
Compiling in support for Mule (multi-lingual Emacs).
Compiling in support for XIM (X11R5+ I18N input method).
- Using raw Xlib to provide XIM support.
Mail:
Compiling in support for "dot-locking" mail spool file locking method.
Other Features:
Inhibiting IPv6 canonicalization at startup.
Compiling in support for dynamic shared object modules.
Compiling in support for extra debugging code.
WARNING: ---------------------------------------------------------
WARNING: Compiling in support for runtime error checking.
WARNING: XEmacs will run noticeably more slowly as a result.
WARNING: Error checking is on by default for XEmacs beta releases.
WARNING: ---------------------------------------------------------
Load-Path Lisp Shadows:
----------------------
(/usr/local/lib/xemacs/xemacs-packages/lisp/pcl-cvs/easy-mmode
/usr/local/lib/xemacs/xemacs-packages/lisp/xemacs-base/easy-mmode
/usr/local/lib/xemacs/site-packages/lisp/patcher
/usr/local/lib/xemacs/xemacs-packages/lisp/xemacs-devel/patcher
/usr/local/lib/xemacs/mule-packages/lisp/mule-base/viet-util
/usr/local/lib/xemacs-21.5-b7/lisp/mule/viet-util
/usr/local/lib/xemacs/mule-packages/lisp/mule-base/korea-util
/usr/local/lib/xemacs-21.5-b7/lisp/mule/korea-util
/usr/local/lib/xemacs/mule-packages/lisp/mule-base/japan-util
/usr/local/lib/xemacs-21.5-b7/lisp/mule/japan-util
/usr/local/lib/xemacs/mule-packages/lisp/mule-base/ethio-util
/usr/local/lib/xemacs-21.5-b7/lisp/mule/ethio-util
/usr/local/lib/xemacs/mule-packages/lisp/mule-base/cyril-util
/usr/local/lib/xemacs-21.5-b7/lisp/mule/cyril-util
/usr/local/lib/xemacs/mule-packages/lisp/mule-base/china-util
/usr/local/lib/xemacs-21.5-b7/lisp/mule/china-util)
Installed XEmacs Packages:
-------------------------
((xemacs-devel:version 1.46 :type single-file)
(xemacs-base :version 1.65 :type regular)
(w3 :version 1.25 :type regular)
(vm :version 7.0 :type regular)
(vc-cc :version 1.18 :type regular)
(text-modes :version 1.48 :type single-file)
(speedbar :version 1.22 :type regular)
(sh-script :version 1.14 :type regular)
(semantic :version 1.11 :type regular)
(psgml :version 1.26 :type regular)
(ps-print :version 1.03 :type regular)
(prog-modes
:version
1
.59
:type
single-file)
(pcl-cvs :version 1.6 :type regular)
(net-utils :version 1.23 :type single-file)
(mew :version 1.14 :type regular)
(mailcrypt :version 2.09 :type regular)
(mail-lib :version 1.43 :type regular)
(jde :version 1.35 :type regular)
(ispell :version 1.24 :type regular)
(ilisp :version 1.2 :type regular)
(igrep :version 1.08 :type regular)
(gnus :version 1.57 :type regular)
(games :version 1.13 :type regular)
(fsf-compat :version 1.11 :type single-file)
(eterm :version 1.13 :type regular)
(emerge :version 1.09 :type regular)
(elib :version 1.1 :type single-file)
(eieio :version 1.02 :type regular)
(efs :version 1.28 :type regular)
(edit-utils :version 1.89 :type single-file)
(ediff :version 1.41 :type regular)
(edebug :version 1.14 :type regular)
(dired :version 1.12 :type regular)
(debug :version 1.14 :type regular)
(cc-mode :version 1.28 :type regular)
(calendar :version 1.18 :type regular)
(mule-base :version 1.39 :type regular)
(leim :version 1.17 :type regular))
Features:
--------
(mail-abbrevs xemacsbug shadow w3-style rect ethio-util w3-hot
url-file url-cache w3-xemac w3-xemacs w3-toolbar xbm-button xpm-button
w3-forms images url-http url-cookie timezone urlauth w3 w3-menu
url-news url-gw w3-script w3-jscript w3-elisp w3-java w3-emulate
w3-auto w3-parse url mm w3-display w3-mouse advice advice-preload
w3-imap w3-widget w3-vars w3-keyword w3-cus url-parse url-vars css
font disp-table mule-sysdp w3-cfg w3-sysdp quail python-mode shell
comint ring edmacro psgml-dtd psgml-parse psgml-edit sendmail rfc822
browse-url tempo psgml-html psgml-xemacs sgml-mode psgml php-mode
cc-mode cc-align cc-cmds cc-engine cc-styles cc-langs cc-vars cc-menus
imenu cc-defs regexp-opt speedbar sb-image dframe assoc compile
dired-faces dired-xemacs dired cus-edit cus-load wid-edit font-lock
cperl-mode efs-cu cus-face overlay remem xemacs-devel-autoloads
xemacs-base-autoloads w3-autoloads vm-autoloads vc-cc-autoloads
text-modes-autoloads speedbar-autoloads sh-script-autoloads
semantic-autoloads psgml-autoloads ps-print-autoloads
prog-modes-autoloads pcl-cvs-autoloads net-utils-autoloads
mew-autoloads mailcrypt-autoloads mail-lib-autoloads jde-autoloads
ispell-autoloads ilisp-autoloads igrep-autoloads gnus-autoloads
games-autoloads fsf-compat-autoloads eterm-autoloads emerge-autoloads
elib-autoloads eieio-autoloads efs-autoloads edit-utils-autoloads
ediff-autoloads edebug-autoloads dired-autoloads debug-autoloads
cc-mode-autoloads calendar-autoloads mule-base-autoloads
leim-autoloads src-autoloads loadhist rsz-minibuf auto-show
fontl-hooks x-iso8859-1 tibetan lao devanagari indian slovenian czech
romanian ccl code-cmds gutter-items menubar-items x-menubar
mode-motion mouse behavior itimer auto-save lisp-mode easymenu
iso8859-1 page buff-menu lib-complete cus-file derived env text-props
frame obsolete cus-start custom widget cl-extra mini-cl cl cl-19
packages backquote very-early-lisp unicode lucid-scrollbars cut-buffer
lucid-menubars x c-balloon-help tty-frames tty toolbar esd-sound
native-sound scrollbar unix-processes multicast network-streams
subprocesses modules menu-accelerator-support menubar berkeley-db dbm
md5 xemacs xim mule gutter tiff png gif jpeg xpm xbm lisp-float-type
file-coding linux devices window-system base64)
Recent keystrokes:
-----------------
C-f BS BS BS BS BS BS BS a r / 7 6 . h TAB RET C-x
b RET up C-SPC down C-insert C-x b RET Sh-insert BS
button1 button1up left BS BS b r down BS button1 button1up
BS BS BS down end BS BS BS BS < b r > down BS down
end BS BS BS b r > down BS C-left C-left C-left C-left
C-left BS BS BS down C-d C-d C-d C-d " end BS BS BS
BS down down home TAB M-x r e p o r t - x e TAB RE
T
Recent messages (most recent first):
-----------------------------------
Loading xemacsbug...done
Loading xemacsbug...
Quit
Warning: Error in post-gc-hook: (quit nil)
Backtrace follows:
# bind (inhibit-quit)
# (unwind-protect ...)
# (unwind-protect ...)
# (catch #<INTERNAL OBJECT (XEmacs bug?) (opaque, size=0) 0x83cf610> ...)
# (unwind-protect ...)
# (unwind-protect ...)
# bind (args)
#<compiled-function (&rest args) "...(28)" [result args reverse cons] 4
640435>((quote progn) (append (if move (\` ((forward-char (\, (length ds)))))) (if (not
(eq move (quote check))) (quote (t)))))
(bq-list* (quote progn) (append (if move (\` ((forward-char (\, (length ds)))))) (if
(not (eq move (quote check))) (quote (t)))))
(cons (bq-list* (quote progn) (append (if move (\` ((forward-char (\, (length ds))))))
(if (not (eq move (quote check))) (quote (t))))) (if (eq move (quote check)) (\`
((sgml-delimiter-parse-error (\, delim))))))
(cons (bq-list* (quote and) (append (loop for i from 0 below (length ds) collect (\` (eq
(\, (aref ds i)) (sgml-following-char (\, (+ i offset)))))) (list (bq-list* (quote or)
(loop for c in context collect (cond ((eq c (quote nmstart)) (\` (sgml-startnm-char (or
(sgml-following-char (\, (length ds))) 0)))) ((eq c (quote stagc)) (\` (and
sgml-current-shorttag (sgml-is-delim "TAGC" nil nil (\, (length ds)))))) ((eq c
(quote digit)) (\` (memq (sgml-following-char (\, (length ds))) (quote (?0 ?1 ?2 ?3 ?4 ?5
?6 ?7 ?8 ?9))))) ((stringp c) (\` (sgml-is-delim (\, c) nil nil (\, (length ds))))) ((eq c
t)) (t (error "Context type: %s" c)))))))) (cons (bq-list* (quote progn) (append
(if move (\` ((forward-char (\, (length ds)))))) (if (not (eq move (quote check))) (quote
(t))))) (if (eq move (quote check)) (\` ((sgml-delimiter-parse-error (\, delim)))))))
(cons (quote if) (cons (bq-list* (quote and) (append (loop for i from 0 below (length
ds) collect (\` (eq (\, (aref ds i)) (sgml-following-char (\, (+ i offset)))))) (list
(bq-list* (quote or) (loop for c in context collect (cond ((eq c (quote nmstart)) (\`
(sgml-startnm-char (or (sgml-following-char (\, (length ds))) 0)))) ((eq c (quote stagc))
(\` (and sgml-current-shorttag (sgml-is-delim "TAGC" nil nil (\, (length
ds)))))) ((eq c (quote digit)) (\` (memq (sgml-following-char (\, (length ds))) (quote (?0
?1 ?2 ?3 ?4 ?5 ?6 ?7 ?8 ?9))))) ((stringp c) (\` (sgml-is-delim (\, c) nil nil (\, (length
ds))))) ((eq c t)) (t (error "Context type: %s" c)))))))) (cons (bq-list* (quote
progn) (append (if move (\` ((forward-char (\, (length ds)))))) (if (not (eq move (quote
check))) (quote (t))))) (if (eq move (quote check)) (\` ((sgml-delimiter-parse-error (\,
delim))))))))
(bq-list* (quote if) (bq-list* (quote and) (append (loop for i from 0 below (length ds)
collect (\` (eq (\, (aref ds i)) (sgml-following-char (\, (+ i offset)))))) (list
(bq-list* (quote or) (loop for c in context collect (cond ((eq c (quote nmstart)) (\`
(sgml-startnm-char (or (sgml-following-char (\, (length ds))) 0)))) ((eq c (quote stagc))
(\` (and sgml-current-shorttag (sgml-is-delim "TAGC" nil nil (\, (length
ds)))))) ((eq c (quote digit)) (\` (memq (sgml-following-char (\, (length ds))) (quote (?0
?1 ?2 ?3 ?4 ?5 ?6 ?7 ?8 ?9))))) ((stringp c) (\` (sgml-is-delim (\, c) nil nil (\, (length
ds))))) ((eq c t)) (t (error "Context type: %s" c)))))))) (bq-list* (quote
progn) (append (if move (\` ((forward-char (\, (length ds)))))) (if (not (eq move (quote
check))) (quote (t))))) (if (eq move (quote check)) (\` ((sgml-delimiter-parse-error (\,
delim))))))
(\` (if (and (\,@ (loop for i from 0 below (length ds) collect (\` (eq (\, (aref ds i))
(sgml-following-char (\, (+ i offset))))))) (or (\,@ (loop for c in context collect (cond
((eq c (quote nmstart)) (\` (sgml-startnm-char (or (sgml-following-char (\, (length ds)))
0)))) ((eq c (quote stagc)) (\` (and sgml-current-shorttag (sgml-is-delim "TAGC"
nil nil (\, (length ds)))))) ((eq c (quote digit)) (\` (memq (sgml-following-char (\,
(length ds))) (quote (?0 ?1 ?2 ?3 ?4 ?5 ?6 ?7 ?8 ?9))))) ((stringp c) (\` (sgml-is-delim
(\, c) nil nil (\, (length ds))))) ((eq c t)) (t (error "Context type: %s"
c))))))) (progn (\,@ (if move (\` ((forward-char (\, (length ds))))))) (\,@ (if (not (eq
move (quote check))) (quote (t))))) (\,@ (if (eq move (quote check)) (\`
((sgml-delimiter-parse-error (\, delim))))))))
# bind (ds)
(let ((ds (sgml-get-delim-string delim))) (assert ds) (cond ((eq context (quote gi))
(setq context (quote (nmstart stagc)))) ((eq context (quote com)) (setq context (quote
("COM" "MDC")))) ((null context) (setq context (quote (t)))) ((not
(listp context)) (setq context (list context)))) (\` (if (and (\,@ (loop for i from 0
below (length ds) collect (\` (eq (\, (aref ds i)) (sgml-following-char (\, (+ i
offset))))))) (or (\,@ (loop for c in context collect (cond ((eq c (quote nmstart)) (\`
(sgml-startnm-char (or (sgml-following-char (\, (length ds))) 0)))) ((eq c (quote stagc))
(\` (and sgml-current-shorttag (sgml-is-delim "TAGC" nil nil (\, (length
ds)))))) ((eq c (quote digit)) (\` (memq (sgml-following-char (\, (length ds))) (quote (?0
?1 ?2 ?3 ?4 ?5 ?6 ?7 ?8 ?9))))) ((stringp c) (\` (sgml-is-delim (\, c) nil nil (\, (length
ds))))) ((eq c t)) (t (error "Context type: %s" c))))))) (progn (\,@ (if move
(\` ((forward-char (\, (length ds))))))) (\,@ (if (not (eq move (quote check))) (quote
(t))))) (\,@ (if (eq move (quote check)) (\` ((sgml-delimiter-parse-error (\,
delim)))))))))
# bind (offset move context delim)
(lambda (delim &optional context move offset) "Macro for matching
delimiters.\nSyntax: DELIM &optional CONTEXT MOVE\nwhere DELIM is the delimiter name
(string or symbol), \nCONTEXT the contextual constraint, and\nMOVE is `nil',
`move' or `check'.\n\nTest if the text following point in current buffer matches
the SGML\ndelimiter DELIM. Also check the characters after the delimiter for\nCONTEXT.
Applicable values for CONTEXT is \n`gi' -- name start or TAGC if SHORTTAG
YES,\n`com' -- if COM or MDC,\n`nmstart' -- name start character, \n`stagc' --
TAGC if SHORTTAG YES,\n`digit' -- any Digit,\nstring -- delimiter with that
name,\nlist -- any of the contextual constraints in the list." (or offset (setq
offset 0)) (setq delim (upcase (format "%s" delim))) (let ((ds
(sgml-get-delim-string delim))) (assert ds) (cond ((eq context (quote gi)) (setq context
(quote (nmstart stagc)))) ((eq context (quote com)) (setq context (quote ("COM"
"MDC")))) ((null context) (setq context (quote (t)))) ((not (listp context))
(setq context (list context)))) (\` (if (and (\,@ (loop for i from 0 below (length ds)
collect (\` (eq (\, (aref ds i)) (sgml-following-char (\, (+ i offset))))))) (or (\,@
(loop for c in context collect (cond ((eq c (quote nmstart)) (\` (sgml-startnm-char (or
(sgml-following-char (\, (length ds))) 0)))) ((eq c (quote stagc)) (\` (and
sgml-current-shorttag (sgml-is-delim "TAGC" nil nil (\, (length ds)))))) ((eq c
(quote digit)) (\` (memq (sgml-following-char (\, (length ds))) (quote (?0 ?1 ?2 ?3 ?4 ?5
?6 ?7 ?8 ?9))))) ((stringp c) (\` (sgml-is-delim (\, c) nil nil (\, (length ds))))) ((eq c
t)) (t (error "Context type: %s" c))))))) (progn (\,@ (if move (\`
((forward-char (\, (length ds))))))) (\,@ (if (not (eq move (quote check))) (quote (t)))))
(\,@ (if (eq move (quote check)) (\` ((sgml-delimiter-parse-error (\,
delim))))))))))("RNI" nil move)
(sgml-is-delim "RNI" nil move)
(sgml-parse-delim "RNI")
(if (sgml-parse-delim "RNI") (sgml-check-token "DEFAULT"))
(sgml-parse-rni "DEFAULT")
(or (sgml-parse-rni "DEFAULT") (setq name (sgml-check-name t)))
(cond ((sgml-parse-delim "PERO") (sgml-skip-ps) (setq name (sgml-check-name
t)) (setq dest (sgml-dtd-parameters sgml-dtd-info))) (t (or (sgml-parse-rni
"DEFAULT") (setq name (sgml-check-name t))) (setq dest (sgml-dtd-entities
sgml-dtd-info))))
# bind (extid text notation type dest name)
(let (name dest (type (quote text)) (notation nil) text extid) (cond ((sgml-parse-delim
"PERO") (sgml-skip-ps) (setq name (sgml-check-name t)) (setq dest
(sgml-dtd-parameters sgml-dtd-info))) (t (or (sgml-parse-rni "DEFAULT") (setq
name (sgml-check-name t))) (setq dest (sgml-dtd-entities sgml-dtd-info)))) (sgml-skip-ps)
(setq extid (sgml-parse-external)) (setq text (cond (extid (sgml-skip-ps) (let ((tn
(sgml-parse-entity-type))) (setq type (or (car tn) (quote text))) (unless (eq (cdr tn)
"") (setq notation (cdr tn)))) extid) ((sgml-startnm-char-next) (let ((token
(intern (sgml-check-case (sgml-check-name))))) (sgml-skip-ps) (when (and sgml-xml-p (memq
token (quote (cdata sdata pi starttag endtag ms md)))) (sgml-error "XML forbids %s
entities." (upcase (symbol-name token)))) (cond ((memq token (quote (CDATA SDATA)))
(setq type token) (sgml-check-parameter-literal)) ((eq token (quote PI)) (concat
"<?" (sgml-check-parameter-literal) ">")) ((eq token (quote
STARTTAG)) (sgml-start-tag-of (sgml-check-parameter-literal))) ((eq token (quote ENDTAG))
(sgml-end-tag-of (sgml-check-parameter-literal))) ((eq token (quote MS)) (concat
"<![" (sgml-check-parameter-literal) "]]>")) ((eq token (quote
MD)) (concat "<!" (sgml-check-parameter-literal) ">")))))
((sgml-check-parameter-literal)))) (when dest (sgml-entity-declare name dest type text
notation)))
sgml-declare-entity()
funcall(sgml-declare-entity)
(cond ((eq option (quote ignore)) (sgml-skip-upto-mdc)) (rut (sgml-skip-ps) (funcall
(cdr rut))) (t (sgml-parse-error "Illegal markup declaration %s" tok)))
# bind (rut tok)
(let* ((tok (sgml-parse-nametoken)) (rut (assoc (sgml-check-case tok)
sgml-markup-declaration-table))) (when (and (not (memq option (quote (prolog ignore))))
(member tok (quote ("SGML" "DOCTYPE")))) (sgml-error "%s
declaration is only valid in prolog" tok)) (when (and (not (memq option (quote (dtd
ignore)))) (member tok (quote ("ELEMENT" "ENTITY" "ATTLIST"
"NOTATION" "SHORTREF")))) (sgml-error "%s declaration is only
valid in doctype" tok)) (cond ((eq option (quote ignore)) (sgml-skip-upto-mdc)) (rut
(sgml-skip-ps) (funcall (cdr rut))) (t (sgml-parse-error "Illegal markup declaration
%s" tok))))
(cond ((sgml-startnm-char-next) (setq sgml-markup-type nil) (let* ((tok
(sgml-parse-nametoken)) (rut (assoc (sgml-check-case tok) sgml-markup-declaration-table)))
(when (and (not (memq option (quote (prolog ignore)))) (member tok (quote
("SGML" "DOCTYPE")))) (sgml-error "%s declaration is only valid
in prolog" tok)) (when (and (not (memq option (quote (dtd ignore)))) (member tok
(quote ("ELEMENT" "ENTITY" "ATTLIST" "NOTATION"
"SHORTREF")))) (sgml-error "%s declaration is only valid in doctype"
tok)) (cond ((eq option (quote ignore)) (sgml-skip-upto-mdc)) (rut (sgml-skip-ps) (funcall
(cdr rut))) (t (sgml-parse-error "Illegal markup declaration %s" tok))))) (t
(setq sgml-markup-type (quote comment))))
(cond ((and sgml-xml-p (sgml-parse-xml-comment))) ((sgml-parse-delim "MDO"
(nmstart "COM" "MDC")) (cond ((sgml-startnm-char-next) (setq
sgml-markup-type nil) (let* ((tok (sgml-parse-nametoken)) (rut (assoc (sgml-check-case
tok) sgml-markup-declaration-table))) (when (and (not (memq option (quote (prolog
ignore)))) (member tok (quote ("SGML" "DOCTYPE")))) (sgml-error
"%s declaration is only valid in prolog" tok)) (when (and (not (memq option
(quote (dtd ignore)))) (member tok (quote ("ELEMENT" "ENTITY"
"ATTLIST" "NOTATION" "SHORTREF")))) (sgml-error "%s
declaration is only valid in doctype" tok)) (cond ((eq option (quote ignore))
(sgml-skip-upto-mdc)) (rut (sgml-skip-ps) (funcall (cdr rut))) (t (sgml-parse-error
"Illegal markup declaration %s" tok))))) (t (setq sgml-markup-type (quote
comment)))) (sgml-skip-ps) (sgml-check-delim "MDC") (unless (eq option (quote
ignore)) (when sgml-markup-type (sgml-set-markup-type sgml-markup-type))) t)
((sgml-parse-delim "MS-START") (sgml-do-marked-section)))
# bind (option)
sgml-parse-markup-declaration(dtd)
(cond ((and (eobp) (eq sgml-current-eref eref)) nil) ((sgml-parse-ds))
((sgml-parse-markup-declaration (quote dtd))) ((sgml-parse-delim "MS-END")))
(progn (setq sgml-markup-start (point)) (cond ((and (eobp) (eq sgml-current-eref eref))
nil) ((sgml-parse-ds)) ((sgml-parse-markup-declaration (quote dtd))) ((sgml-parse-delim
"MS-END"))))
(while (progn (setq sgml-markup-start (point)) (cond ((and (eobp) (eq sgml-current-eref
eref)) nil) ((sgml-parse-ds)) ((sgml-parse-markup-declaration (quote dtd)))
((sgml-parse-delim "MS-END")))))
# bind (eref sgml-parsing-dtd)
(let ((sgml-parsing-dtd t) (eref sgml-current-eref)) (while (progn (setq
sgml-markup-start (point)) (cond ((and (eobp) (eq sgml-current-eref eref)) nil)
((sgml-parse-ds)) ((sgml-parse-markup-declaration (quote dtd))) ((sgml-parse-delim
"MS-END"))))))
sgml-check-dtd-subset()
(cond (external (let ((decl (and (car external) (sgml-catalog-lookup sgml-catalog-files
nil (quote dtddecl) (sgml-canonize-pubid (car external)))))) (if decl (setq
sgml-declaration decl))) (sgml-push-to-entity (sgml-make-entity docname (quote dtd)
external)) (sgml-check-dtd-subset) (sgml-check-end-of-entity "DTD subset")
(sgml-pop-entity)))
# bind (sgml-parsing-dtd)
(let ((sgml-parsing-dtd t)) (setq sgml-no-elements 0) (setq sgml-dtd-info (sgml-make-dtd
docname)) (sgml-skip-ps) (cond ((sgml-parse-delim "DSO") (let ((original-buffer
(current-buffer))) (sgml-check-dtd-subset) (if (eq (current-buffer) original-buffer)
(sgml-check-delim "DSC") (sgml-parse-error "Illegal character '%c'
in doctype declaration" (following-char)))))) (cond (external (let ((decl (and (car
external) (sgml-catalog-lookup sgml-catalog-files nil (quote dtddecl) (sgml-canonize-pubid
(car external)))))) (if decl (setq sgml-declaration decl))) (sgml-push-to-entity
(sgml-make-entity docname (quote dtd) external)) (sgml-check-dtd-subset)
(sgml-check-end-of-entity "DTD subset") (sgml-pop-entity)))
(sgml-set-initial-state sgml-dtd-info) (run-hooks (quote sgml-doctype-parsed-hook)))
# bind (external docname)
sgml-setup-doctype("HTML" ("-//W3C//DTD HTML 4.0 Transitional//EN"
"http://www.w3.org/TR/REC-html40/loose.dtd" .
"/usr/local/apache/htdocs/german/bjokes/ar/"))
# bind (sgml-markup-start)
(let (sgml-markup-start) (message "Parsing doctype...") (sgml-setup-doctype
(sgml-check-name) (sgml-parse-external)) (message "Parsing doctype...done"))
(cond (sgml-dtd-info (sgml-skip-upto-mdc)) (t (let (sgml-markup-start) (message
"Parsing doctype...") (sgml-setup-doctype (sgml-check-name)
(sgml-parse-external)) (message "Parsing doctype...done"))))
sgml-do-doctype()
funcall(sgml-do-doctype)
(cond ((eq option (quote ignore)) (sgml-skip-upto-mdc)) (rut (sgml-skip-ps) (funcall
(cdr rut))) (t (sgml-parse-error "Illegal markup declaration %s" tok)))
# bind (rut tok)
(let* ((tok (sgml-parse-nametoken)) (rut (assoc (sgml-check-case tok)
sgml-markup-declaration-table))) (when (and (not (memq option (quote (prolog ignore))))
(member tok (quote ("SGML" "DOCTYPE")))) (sgml-error "%s
declaration is only valid in prolog" tok)) (when (and (not (memq option (quote (dtd
ignore)))) (member tok (quote ("ELEMENT" "ENTITY" "ATTLIST"
"NOTATION" "SHORTREF")))) (sgml-error "%s declaration is only
valid in doctype" tok)) (cond ((eq option (quote ignore)) (sgml-skip-upto-mdc)) (rut
(sgml-skip-ps) (funcall (cdr rut))) (t (sgml-parse-error "Illegal markup declaration
%s" tok))))
(cond ((sgml-startnm-char-next) (setq sgml-markup-type nil) (let* ((tok
(sgml-parse-nametoken)) (rut (assoc (sgml-check-case tok) sgml-markup-declaration-table)))
(when (and (not (memq option (quote (prolog ignore)))) (member tok (quote
("SGML" "DOCTYPE")))) (sgml-error "%s declaration is only valid
in prolog" tok)) (when (and (not (memq option (quote (dtd ignore)))) (member tok
(quote ("ELEMENT" "ENTITY" "ATTLIST" "NOTATION"
"SHORTREF")))) (sgml-error "%s declaration is only valid in doctype"
tok)) (cond ((eq option (quote ignore)) (sgml-skip-upto-mdc)) (rut (sgml-skip-ps) (funcall
(cdr rut))) (t (sgml-parse-error "Illegal markup declaration %s" tok))))) (t
(setq sgml-markup-type (quote comment))))
(cond ((and sgml-xml-p (sgml-parse-xml-comment))) ((sgml-parse-delim "MDO"
(nmstart "COM" "MDC")) (cond ((sgml-startnm-char-next) (setq
sgml-markup-type nil) (let* ((tok (sgml-parse-nametoken)) (rut (assoc (sgml-check-case
tok) sgml-markup-declaration-table))) (when (and (not (memq option (quote (prolog
ignore)))) (member tok (quote ("SGML" "DOCTYPE")))) (sgml-error
"%s declaration is only valid in prolog" tok)) (when (and (not (memq option
(quote (dtd ignore)))) (member tok (quote ("ELEMENT" "ENTITY"
"ATTLIST" "NOTATION" "SHORTREF")))) (sgml-error "%s
declaration is only valid in doctype" tok)) (cond ((eq option (quote ignore))
(sgml-skip-upto-mdc)) (rut (sgml-skip-ps) (funcall (cdr rut))) (t (sgml-parse-error
"Illegal markup declaration %s" tok))))) (t (setq sgml-markup-type (quote
comment)))) (sgml-skip-ps) (sgml-check-delim "MDC") (unless (eq option (quote
ignore)) (when sgml-markup-type (sgml-set-markup-type sgml-markup-type))) t)
((sgml-parse-delim "MS-START") (sgml-do-marked-section)))
# bind (option)
sgml-parse-markup-declaration(prolog)
(and (sgml-parse-markup-declaration (quote prolog)) (null sgml-dtd-info))
(or (sgml-parse-s) (sgml-parse-processing-instruction) (and
(sgml-parse-markup-declaration (quote prolog)) (null sgml-dtd-info)))
(progn (setq sgml-markup-start (point)) (or (sgml-parse-s)
(sgml-parse-processing-instruction) (and (sgml-parse-markup-declaration (quote prolog))
(null sgml-dtd-info))))
(while (progn (setq sgml-markup-start (point)) (or (sgml-parse-s)
(sgml-parse-processing-instruction) (and (sgml-parse-markup-declaration (quote prolog))
(null sgml-dtd-info)))))
(progn (while (progn (setq sgml-markup-start (point)) (or (sgml-parse-s)
(sgml-parse-processing-instruction) (and (sgml-parse-markup-declaration (quote prolog))
(null sgml-dtd-info))))) (unless sgml-dtd-info (let ((docname (or
sgml-default-doctype-name (if (sgml-parse-delim "STAGO" gi)
(sgml-parse-name))))) (when docname (sgml-setup-doctype docname (quote (nil)))))))
# (unwind-protect ...)
(unwind-protect (progn (while (progn (setq sgml-markup-start (point)) (or (sgml-parse-s)
(sgml-parse-processing-instruction) (and (sgml-parse-markup-declaration (quote prolog))
(null sgml-dtd-info))))) (unless sgml-dtd-info (let ((docname (or
sgml-default-doctype-name (if (sgml-parse-delim "STAGO" gi)
(sgml-parse-name))))) (when docname (sgml-setup-doctype docname (quote (nil))))))) (setq
sgml-last-buffer (current-buffer)) (set-buffer cb) (set-syntax-table normal-syntax-table)
(set-buffer-modified-p buffer-modified) (sgml-debug "Restoring buffer mod: %s"
buffer-modified))
# bind (buffer-modified cb normal-syntax-table)
(let ((normal-syntax-table (syntax-table)) (cb (current-buffer)) (buffer-modified
(buffer-modified-p))) (set-syntax-table (if sgml-xml-p xml-parser-syntax
sgml-parser-syntax)) (unwind-protect (progn (while (progn (setq sgml-markup-start (point))
(or (sgml-parse-s) (sgml-parse-processing-instruction) (and (sgml-parse-markup-declaration
(quote prolog)) (null sgml-dtd-info))))) (unless sgml-dtd-info (let ((docname (or
sgml-default-doctype-name (if (sgml-parse-delim "STAGO" gi)
(sgml-parse-name))))) (when docname (sgml-setup-doctype docname (quote (nil))))))) (setq
sgml-last-buffer (current-buffer)) (set-buffer cb) (set-syntax-table normal-syntax-table)
(set-buffer-modified-p buffer-modified) (sgml-debug "Restoring buffer mod: %s"
buffer-modified)))
(sgml-with-parser-syntax-ro (while (progn (setq sgml-markup-start (point)) (or
(sgml-parse-s) (sgml-parse-processing-instruction) (and (sgml-parse-markup-declaration
(quote prolog)) (null sgml-dtd-info))))) (unless sgml-dtd-info (let ((docname (or
sgml-default-doctype-name (if (sgml-parse-delim "STAGO" gi)
(sgml-parse-name))))) (when docname (sgml-setup-doctype docname (quote (nil)))))))
sgml-parse-prolog()
# (unwind-protect ...)
(save-excursion (sgml-parse-prolog))
(cond ((or sgml-parent-document sgml-doctype) (let ((dtd (save-excursion (set-buffer
(find-file-noselect (if (consp sgml-parent-document) (car sgml-parent-document) (or
sgml-doctype sgml-parent-document)))) (sgml-need-dtd) (sgml-pstate-dtd
sgml-buffer-parse-state)))) (sgml-set-initial-state dtd) (when (consp
sgml-parent-document) (sgml-modify-dtd (cdr sgml-parent-document))))) (t (save-excursion
(sgml-parse-prolog))))
sgml-load-doctype()
(if sgml-default-dtd-file (sgml-load-dtd sgml-default-dtd-file) (sgml-load-doctype))
(progn (add-hook (quote pre-command-hook) (quote sgml-reset-log)) (make-local-variable
(quote sgml-auto-fill-inhibit-function)) (setq sgml-auto-fill-inhibit-function (function
sgml-in-prolog-p)) (if sgml-default-dtd-file (sgml-load-dtd sgml-default-dtd-file)
(sgml-load-doctype)))
(if (null sgml-buffer-parse-state) (progn (add-hook (quote pre-command-hook) (quote
sgml-reset-log)) (make-local-variable (quote sgml-auto-fill-inhibit-function)) (setq
sgml-auto-fill-inhibit-function (function sgml-in-prolog-p)) (if sgml-default-dtd-file
(sgml-load-dtd sgml-default-dtd-file) (sgml-load-doctype))))
(when (null sgml-buffer-parse-state) (add-hook (quote pre-command-hook) (quote
sgml-reset-log)) (make-local-variable (quote sgml-auto-fill-inhibit-function)) (setq
sgml-auto-fill-inhibit-function (function sgml-in-prolog-p)) (if sgml-default-dtd-file
(sgml-load-dtd sgml-default-dtd-file) (sgml-load-doctype)))
sgml-need-dtd()
# bind (quiet extra-cond sgml-goal)
sgml-parse-to(758)
# (unwind-protect ...)
(save-excursion (sgml-parse-to (1+ pos)) (let ((u sgml-top-tree)) (while (cond ((and
(sgml-tree-next u) (>= pos (sgml-element-start (sgml-tree-next u)))) (setq u
(sgml-tree-next u))) ((and (sgml-tree-etag-epos u) (>= pos (sgml-tree-end u))) (setq u
(sgml-tree-parent u)) nil) ((and (sgml-tree-content u) (>= pos (sgml-element-start
(sgml-tree-content u)))) (setq u (sgml-tree-content u))))) u))
# bind (pos)
sgml-find-element-of(757)
(if (eobp) (sgml-find-context-of (point)) (sgml-find-element-of (point)))
# (catch parse-error ...)
(catch sgml-throw-on-error (if (eobp) (sgml-find-context-of (point))
(sgml-find-element-of (point))))
# bind (sgml-throw-on-error)
(let ((sgml-throw-on-error (quote parse-error))) (catch sgml-throw-on-error (if (eobp)
(sgml-find-context-of (point)) (sgml-find-element-of (point)))))
(setq element (let ((sgml-throw-on-error (quote parse-error))) (catch
sgml-throw-on-error (if (eobp) (sgml-find-context-of (point)) (sgml-find-element-of
(point))))))
(if (or col element) nil (setq element (let ((sgml-throw-on-error (quote parse-error)))
(catch sgml-throw-on-error (if (eobp) (sgml-find-context-of (point)) (sgml-find-element-of
(point)))))))
(unless (or col element) (setq element (let ((sgml-throw-on-error (quote parse-error)))
(catch sgml-throw-on-error (if (eobp) (sgml-find-context-of (point)) (sgml-find-element-of
(point)))))))
# bind (here)
(let ((here (point-marker))) (back-to-indentation) (unless (or col element) (setq
element (let ((sgml-throw-on-error (quote parse-error))) (catch sgml-throw-on-error (if
(eobp) (sgml-find-context-of (point)) (sgml-find-element-of (point))))))) (when (eq
element sgml-top-tree) (setq element nil) (goto-char here)) (when element
(sgml-with-parser-syntax (let ((stag (sgml-is-start-tag)) (etag (sgml-is-end-tag))) (cond
((and (> (point) (sgml-element-start element)) (< (point) (sgml-element-stag-end
element))) (setq col (+ (save-excursion (goto-char (sgml-element-start element))
(current-column)) (length (sgml-element-gi element)) 2))) ((and (not (member*
(sgml-element-gi (if (or stag etag) (sgml-element-parent element) element))
sgml-inhibit-indent-tags :test (function equalp))) (or sgml-indent-data (not
(sgml-element-data-p (if stag (sgml-element-parent element) element)))) (setq col (*
sgml-indent-step (+ (if (or stag etag) -1 0) (sgml-element-level element)))))))))) (when
(and col (/= col (current-column))) (beginning-of-line 1) (delete-horizontal-space)
(indent-to col)) (when (< (point) here) (goto-char here)) col)
(if sgml-indent-step (let ((here (point-marker))) (back-to-indentation) (unless (or col
element) (setq element (let ((sgml-throw-on-error (quote parse-error))) (catch
sgml-throw-on-error (if (eobp) (sgml-find-context-of (point)) (sgml-find-element-of
(point))))))) (when (eq element sgml-top-tree) (setq element nil) (goto-char here)) (when
element (sgml-with-parser-syntax (let ((stag (sgml-is-start-tag)) (etag
(sgml-is-end-tag))) (cond ((and (> (point) (sgml-element-start element)) (< (point)
(sgml-element-stag-end element))) (setq col (+ (save-excursion (goto-char
(sgml-element-start element)) (current-column)) (length (sgml-element-gi element)) 2)))
((and (not (member* (sgml-element-gi (if (or stag etag) (sgml-element-parent element)
element)) sgml-inhibit-indent-tags :test (function equalp))) (or sgml-indent-data (not
(sgml-element-data-p (if stag (sgml-element-parent element) element)))) (setq col (*
sgml-indent-step (+ (if (or stag etag) -1 0) (sgml-element-level element)))))))))) (when
(and col (/= col (current-column))) (beginning-of-line 1) (delete-horizontal-space)
(indent-to col)) (when (< (point) here) (goto-char here)) col))
(when sgml-indent-step (let ((here (point-marker))) (back-to-indentation) (unless (or
col element) (setq element (let ((sgml-throw-on-error (quote parse-error))) (catch
sgml-throw-on-error (if (eobp) (sgml-find-context-of (point)) (sgml-find-element-of
(point))))))) (when (eq element sgml-top-tree) (setq element nil) (goto-char here)) (when
element (sgml-with-parser-syntax (let ((stag (sgml-is-start-tag)) (etag
(sgml-is-end-tag))) (cond ((and (> (point) (sgml-element-start element)) (< (point)
(sgml-element-stag-end element))) (setq col (+ (save-excursion (goto-char
(sgml-element-start element)) (current-column)) (length (sgml-element-gi element)) 2)))
((and (not (member* (sgml-element-gi (if (or stag etag) (sgml-element-parent element)
element)) sgml-inhibit-indent-tags :test (function equalp))) (or sgml-indent-data (not
(sgml-element-data-p (if stag (sgml-element-parent element) element)))) (setq col (*
sgml-indent-step (+ (if (or stag etag) -1 0) (sgml-element-level element)))))))))) (when
(and col (/= col (current-column))) (beginning-of-line 1) (delete-horizontal-space)
(indent-to col)) (when (< (point) here) (goto-char here)) col))
# bind (element col)
sgml-indent-line()
funcall(sgml-indent-line)
(if (null sgml-indent-step) (insert-tab) (funcall indent-line-function))
(lambda nil "Indent line in proper way for current major mode." (interactive)
(if (null sgml-indent-step) (insert-tab) (funcall indent-line-function)))()
call-interactively(sgml-indent-or-tab)
# (condition-case ... . error)
# (catch top-level ...)
Parsing doctype...
Parsing prolog...
Fontifying 76.html... done.
Fontifying 76.html... (regexps).................
Fontifying 76.html... (regexps)................
Fontifying 76.html... (regexps)................
Fontifying 76.html... (regexps)................
Fontifying 76.html... (regexps)...............
Fontifying 76.html... (regexps)..............
Fontifying 76.html... (regexps).............
Fontifying 76.html... (regexps).............
Fontifying 76.html... (regexps)............
Fontifying 76.html... (regexps).......
Fontifying 76.html... (regexps).......
Fontifying 76.html... (regexps).......
Fontifying 76.html... (regexps)......