unofficial mirror of emacs-devel@gnu.org 
 help / color / mirror / code / Atom feed
* [patch] use font-lock
@ 2008-05-23 22:26 Daniel Colascione
  2008-05-24 20:38 ` Stefan Monnier
  0 siblings, 1 reply; 24+ messages in thread
From: Daniel Colascione @ 2008-05-23 22:26 UTC (permalink / raw
  To: emacs-devel

[-- Attachment #1: Type: text/plain, Size: 1277 bytes --]

[Originally sent to the nxml mailing list]

I've converted nxml to font-lock. I used the existing fontification machinery 
and put it inside a cc-mode-style matcher. Efficiency and output are the 
same, but:

1) hi-lock-mode works now
2) all conventional font-locking functions work as expected. For example, you 
can turn fontification on and off with M-x font-lock-mode.
3) font-lock-add-keywords DTRT
4) multiple-major-modes modes should be able to use nXML fontification now, 
though this remains untested

I've also added a new function:
nxml-debug-region: Interactive function. Activate the region and call 
nxml-debug-region. The new region is what nxml thinks should be re-fontified 
if the original region is changed.

The new code probably works only on Emacs 22. Lightly tested, but it seems to 
handle corner highlighting cases fine. I removed a bunch of code that 
was "for redisplay", since I'm assuming font-lock handles those funky bits.

In addition to the patch, I've attached a set of files that demonstrates 
extending nXML mode to work with the Genshi template engine. The examples 
ought to work with some slight modification of the embedded paths.

(Does the Relax NG compact syntax offer a way to say "include the next file 
for this document type"?)



[-- Attachment #2: nxml-font-lock.patch --]
[-- Type: text/x-diff, Size: 16255 bytes --]

Index: rng-auto.el
===================================================================
--- rng-auto.el	(revision 44)
+++ rng-auto.el	(working copy)
@@ -106,12 +106,9 @@
 (autoload (quote nxml-mode) "nxml-mode" "\
 Major mode for editing XML.
 
-Syntax highlighting is performed unless the variable
-`nxml-syntax-highlight-flag' is nil.
-
 \\[nxml-finish-element] finishes the current element by inserting an end-tag.
 C-c C-i closes a start-tag with `>' and then inserts a balancing end-tag
-leaving point between the start-tag and end-tag. 
+leaving point between the start-tag and end-tag.
 \\[nxml-balanced-close-start-tag-block] is similar but for block rather than inline elements:
 the start-tag, point, and end-tag are all left on separate lines.
 If `nxml-slash-auto-complete-flag' is non-nil, then inserting a `</'
Index: nxml-mode.el
===================================================================
--- nxml-mode.el	(revision 44)
+++ nxml-mode.el	(working copy)
@@ -26,11 +26,6 @@
 
 ;; See nxml-rap.el for description of parsing strategy.
 
-;; The font locking here is independent of font-lock.el.  We want to
-;; do more sophisticated handling of changes and we want to use the
-;; same xmltok rather than regexps for parsing so that we parse
-;; consistently and correctly.
-
 ;;; Code:
 
 (when (featurep 'mucs)
@@ -55,11 +50,6 @@
   :group 'nxml
   :group 'font-lock-highlighting-faces)
 
-(defcustom nxml-syntax-highlight-flag t
-  "*Non-nil means nxml-mode should perform syntax highlighting."
-  :group 'nxml
-  :type 'boolean)
-
 (defcustom nxml-char-ref-display-glyph-flag t
   "*Non-nil means display glyph following character reference.
 The glyph is displayed in `nxml-glyph-face'.  The hook
@@ -99,8 +89,6 @@
   :group 'nxml
   :type 'integer)
 
-(defvar nxml-fontify-chunk-size 500)
-
 (defcustom nxml-bind-meta-tab-to-complete-flag (not window-system)
   "*Non-nil means bind M-TAB in `nxml-mode-map' to `nxml-complete'.
 C-return will be bound to `nxml-complete' in any case.
@@ -463,20 +451,22 @@
     map)
   "Keymap for nxml-mode.")
 
+(defvar nxml-font-lock-keywords
+  '(nxml-fontify-matcher)
+  "Default font lock keywords for nxml-mode")
+
 (defsubst nxml-set-face (start end face)
   (when (and face (< start end))
-    (put-text-property start end 'face face)))
+    (font-lock-append-text-property start end 'face face)))
 
-(defun nxml-clear-face (start end)
-  (remove-text-properties start end '(face nil))
-  (nxml-clear-char-ref-extra-display start end))
+(defsubst nxml-debug (format &rest args)
+  ;(apply #'message format args)
+  )
 
-(defsubst nxml-set-fontified (start end)
-  (put-text-property start end 'fontified t))
+(defsubst nxml-debug-change (name start end)
+  ;(nxml-debug "%s: %S" name (buffer-substring-no-properties start end))
+  )
 
-(defsubst nxml-clear-fontified (start end)
-  (remove-text-properties start end '(fontified nil)))
-
 ;;;###autoload
 (defun nxml-mode ()
   ;; We use C-c C-i instead of \\[nxml-balanced-close-start-tag-inline]
@@ -484,9 +474,6 @@
   ;; not mnemonic.
   "Major mode for editing XML.
 
-Syntax highlighting is performed unless the variable
-`nxml-syntax-highlight-flag' is nil.
-
 \\[nxml-finish-element] finishes the current element by inserting an end-tag.
 C-c C-i closes a start-tag with `>' and then inserts a balancing end-tag
 leaving point between the start-tag and end-tag.
@@ -570,13 +557,9 @@
       (nxml-clear-dependent-regions (point-min) (point-max))
       (setq nxml-scan-end (copy-marker (point-min) nil))
       (nxml-with-unmodifying-text-property-changes
-	(when nxml-syntax-highlight-flag
-	  (nxml-clear-fontified (point-min) (point-max)))
-	(nxml-clear-inside (point-min) (point-max))
+        (nxml-clear-inside (point-min) (point-max))
 	(nxml-with-invisible-motion
 	  (nxml-scan-prolog)))))
-  (when nxml-syntax-highlight-flag
-    (add-hook 'fontification-functions 'nxml-fontify nil t))
   (add-hook 'after-change-functions 'nxml-after-change nil t)
   (add-hook 'write-contents-hooks 'nxml-prepare-to-save)
   (when (not (and (buffer-file-name) (file-exists-p (buffer-file-name))))
@@ -585,6 +568,18 @@
       (setq buffer-file-coding-system nxml-default-buffer-file-coding-system))
     (when nxml-auto-insert-xml-declaration-flag
       (nxml-insert-xml-declaration)))
+
+  (setq font-lock-defaults
+        '(nxml-font-lock-keywords
+          t    ; keywords-only; we highlight comments and strings here
+          nil  ; font-lock-keywords-case-fold-search. XML is case sensitive
+          nil  ; no special syntax table
+          nil  ; no automatic syntactic fontification
+          (font-lock-extend-after-change-region-function
+           . nxml-extend-after-change-region)
+          (font-lock-extend-region-functions . (nxml-extend-region))
+          (font-lock-unfontify-region-function . nxml-unfontify-region)))
+
   (run-hooks 'nxml-mode-hook))
 
 (defun nxml-degrade (context err)
@@ -598,85 +593,91 @@
     (save-restriction
       (widen)
       (nxml-with-unmodifying-text-property-changes
-	(nxml-clear-face (point-min) (point-max))
-	(nxml-set-fontified (point-min) (point-max))
-	(nxml-clear-inside (point-min) (point-max)))
+        (nxml-clear-inside (point-min) (point-max)))
       (setq mode-name "nXML/degraded"))))
 
 ;;; Change management
 
+(defun nxml-debug-region (start end)
+  (interactive "r")
+  (let ((font-lock-beg start)
+        (font-lock-end end))
+    (nxml-extend-region)
+    (goto-char font-lock-beg)
+    (set-mark font-lock-end)))
+
 (defun nxml-after-change (start end pre-change-length)
-  ;; Work around bug in insert-file-contents.
-  (when (> end (1+ (buffer-size)))
-    (setq start 1)
-    (setq end (1+ (buffer-size))))
-  (unless nxml-degraded
+  ; in font-lock mode, nxml-after-change1 is called via
+  ; nxml-extend-after-change-region instead so that the updated
+  ; book-keeping information is available for fontification.
+
+  (unless (or font-lock-mode nxml-degraded)
     (condition-case err
-	(save-excursion
-	  (save-restriction
-	    (widen)
-	    (save-match-data
-	      (nxml-with-invisible-motion
-		(nxml-with-unmodifying-text-property-changes
-		  (nxml-after-change1 start end pre-change-length))))))
+        (save-excursion
+          (save-restriction
+            (widen)
+            (save-match-data
+              (nxml-with-invisible-motion
+                (nxml-with-unmodifying-text-property-changes
+                  (nxml-after-change1
+                   start end pre-change-length))))))
+
       (error
        (nxml-degrade 'nxml-after-change err)))))
 
 (defun nxml-after-change1 (start end pre-change-length)
-  (setq nxml-last-fontify-end nil)
+  "after-change book-keeping. returns a cons containing a
+possibly-enlarged change region. you must still call
+nxml-extend-region on this expanded region to obtain the full
+extent of the area needing refontification.
+
+For book-keeping, call this function even when fontification is
+disabled."
+  ;; Work around bug in insert-file-contents, apparently
+  (when (> end (1+ (buffer-size)))
+    (setq start 1)
+    (setq end (1+ (buffer-size))))
+
   (let ((pre-change-end (+ start pre-change-length)))
     (setq start
 	  (nxml-adjust-start-for-dependent-regions start
-						   end
-						   pre-change-length))
+                                                   end
+                                                   pre-change-length))
+
+    ;; If the prolog might have changed, rescan the prolog
     (when (<= start
-	      ;; Add 2 so as to include the < and following char
-	      ;; that start the instance, since changing these
-	      ;; can change where the prolog ends.
+	      ;; Add 2 so as to include the < and following char that
+	      ;; start the instance (document element), since changing
+	      ;; these can change where the prolog ends.
 	      (+ nxml-prolog-end 2))
-      ;; end must be extended to at least the end of the old prolog
+      ;; end must be extended to at least the end of the old prolog in
+      ;; case the new prolog is shorter
       (when (< pre-change-end nxml-prolog-end)
 	(setq end
 	      ;; don't let end get out of range even if pre-change-length
 	      ;; is bogus
 	      (min (point-max)
 		   (+ end (- nxml-prolog-end pre-change-end)))))
+
       (nxml-scan-prolog)))
-  (cond ((<= end nxml-prolog-end)
-	 (setq end nxml-prolog-end)
-	 (goto-char start)
-	 ;; This is so that Emacs redisplay works
-	 (setq start (line-beginning-position)))
-	((and (<= start nxml-scan-end)
-	      (> start (point-min))
-	      (nxml-get-inside (1- start)))
-	 ;; The closing delimiter might have been removed.
-	 ;; So we may need to redisplay from the beginning
-	 ;; of the token.
-	 (goto-char (1- start))
-	 (nxml-move-outside-backwards)
-	 ;; This is so that Emacs redisplay works
-	 (setq start (line-beginning-position))
-	 (setq end (max (nxml-scan-after-change (point) end)
-			end)))
-	(t
-	 (goto-char start)
-	 ;; This is both for redisplay and to move back
-	 ;; past any incomplete opening delimiters
-	 (setq start (line-beginning-position))
-	 (setq end (max (nxml-scan-after-change start end)
-			end))))
-  (when nxml-syntax-highlight-flag
-    (when (>= start end)
-      ;; Must clear at least one char so as to trigger redisplay.
-      (cond ((< start (point-max))
-	     (setq end (1+ start)))
-	    (t
-	     (setq end (point-max))
-	     (goto-char end)
-	     (setq start (line-beginning-position)))))
-    (nxml-clear-fontified start end)))
 
+  (when (> end nxml-prolog-end)
+    (when (and (<= start nxml-scan-end)
+               (> start (point-min))
+               (nxml-get-inside (1- start)))
+      ;; The closing delimiter might have been removed.
+      ;; So we may need to redisplay from the beginning
+      ;; of the token.
+      (goto-char (1- start))
+      (nxml-move-outside-backwards)
+      (setq start (point)))
+
+    (setq end (max (nxml-scan-after-change start end)
+                   end)))
+
+  (nxml-debug-change "nxml-after-change1" start end)
+  (cons start end))
+
 ;;; Encodings
 
 (defun nxml-insert-xml-declaration ()
@@ -862,59 +863,113 @@
 
 ;;; Fontification
 
-(defun nxml-fontify (start)
-  (condition-case err
-      (save-excursion
-	(save-restriction
-	  (widen)
-	  (save-match-data
-	    (nxml-with-invisible-motion
-	      (nxml-with-unmodifying-text-property-changes
-		(if (or nxml-degraded
-			;; just in case we get called in the wrong buffer
-			(not nxml-prolog-end))
-		    (nxml-set-fontified start (point-max))
-		  (nxml-fontify1 start)))))))
-    (error
-     (nxml-degrade 'nxml-fontify err))))
+(defun nxml-unfontify-region (start end)
+  (font-lock-default-unfontify-region start end)
+  (nxml-clear-char-ref-extra-display start end))
 
-(defun nxml-fontify1 (start)
-  (cond ((< start nxml-prolog-end)
-	 (nxml-fontify-prolog)
-	 (nxml-set-fontified (point-min)
-			     nxml-prolog-end))
-	(t
-	 (goto-char start)
-	 (when (not (eq nxml-last-fontify-end start))
-	   (when (not (equal (char-after) ?\<))
-	     (search-backward "<" nxml-prolog-end t))
-	   (nxml-ensure-scan-up-to-date)
-	   (nxml-move-outside-backwards))
-	 (let ((start (point)))
-	   (nxml-do-fontify (min (point-max)
-				 (+ start nxml-fontify-chunk-size)))
-	   (setq nxml-last-fontify-end (point))
-	   (nxml-set-fontified start nxml-last-fontify-end)))))
+(defun nxml-extend-region ()
+  "Extend the region to hold the minimum area we can fontify with
+nXML. Called with font-lock-beg and font-lock-end dynamically bound."
+  (let ((start font-lock-beg)
+        (end font-lock-end))
 
-(defun nxml-fontify-buffer ()
-  (interactive)
-  (save-excursion
-    (save-restriction
-      (widen)
-      (nxml-with-invisible-motion
-	(goto-char (point-min))
-	(nxml-with-unmodifying-text-property-changes
-	  (nxml-fontify-prolog)
-	  (goto-char nxml-prolog-end)
-	  (nxml-do-fontify))))))
+    (nxml-debug-change "nxml-extend-region(input)" start end)
 
+    (when (< start nxml-prolog-end)
+      (setq start (point-min)))
+
+    (cond ((<= end nxml-prolog-end)
+           (setq end nxml-prolog-end))
+
+          (t
+           (goto-char start)
+           ;; some font-lock backends (like Emacs 22 jit-lock) snap
+           ;; the region to the beginning of the line no matter what
+           ;; we say here. To mitigate the resulting excess
+           ;; fontification, ignore leading whitespace.
+           (skip-syntax-forward " ")
+
+           ;; find the beginning of the previous tag
+           (when (not (equal (char-after) ?\<))
+             (search-backward "<" nxml-prolog-end t))
+           (nxml-ensure-scan-up-to-date)
+           (nxml-move-outside-backwards)
+           (setq start (point))
+
+           (while (< (point) end)
+             (nxml-tokenize-forward))
+
+           (setq end (point))))
+
+    (when (or (< start font-lock-beg)
+              (> end font-lock-end))
+      (setq font-lock-beg start
+            font-lock-end end)
+      (nxml-debug-change "nxml-extend-region" start end)
+      t)))
+
+(defun nxml-extend-after-change-region (start end pre-change-length)
+  (unless nxml-degraded
+    (setq nxml-last-fontify-end nil)
+
+    (when (> end (1+ (buffer-size)))
+    (setq start 1)
+    (setq end (1+ (buffer-size))))
+
+    (condition-case err
+	(save-excursion
+	  (save-restriction
+	    (widen)
+	    (save-match-data
+	      (nxml-with-invisible-motion
+		(nxml-with-unmodifying-text-property-changes
+                  (nxml-extend-after-change-region1 start end pre-change-length))))))
+      (error
+       (nxml-degrade 'nxml-extend-after-change-region err)))))
+
+(defun nxml-extend-after-change-region1 (start end pre-change-length)
+  (let* ((region (nxml-after-change1 start end pre-change-length))
+         (font-lock-beg (car region))
+         (font-lock-end (cdr region)))
+
+    (nxml-extend-region)
+    (cons font-lock-beg font-lock-end)))
+
+(defun nxml-fontify-matcher (bound)
+  "Called as font-lock keyword matcher."
+
+  (unless nxml-degraded
+    (nxml-debug-change "nxml-fontify-matcher" (point) bound)
+
+    (when (< (point) nxml-prolog-end)
+      (goto-char (point-min))
+      (nxml-fontify-prolog)
+      (goto-char nxml-prolog-end))
+
+    (when (not (eq nxml-last-fontify-end (point)))
+      (when (not (equal (char-after) ?\<))
+        (search-backward "<" nxml-prolog-end t))
+      (nxml-ensure-scan-up-to-date)
+      (nxml-move-outside-backwards))
+
+    (let (xmltok-dependent-regions
+          xmltok-errors)
+      (while (and (< (point) bound)
+                  (nxml-tokenize-forward))
+        (nxml-apply-fontify-rule)))
+
+    (setq nxml-last-fontify-end (point)))
+
+  ;; Since we did the fontification internally, tell font-lock to not
+  ;; do anything itself.
+  nil)
+
 (defun nxml-fontify-prolog ()
   "Fontify the prolog.
 The buffer is assumed to be prepared for fontification.
 This does not set the fontified property, but it does clear
 faces appropriately."
   (let ((regions nxml-prolog-regions))
-    (nxml-clear-face (point-min) nxml-prolog-end)
     (while regions
       (let ((region (car regions)))
 	(nxml-apply-fontify-rule (aref region 0)
@@ -922,17 +977,6 @@
 				 (aref region 2)))
       (setq regions (cdr regions)))))
 
-(defun nxml-do-fontify (&optional bound)
-  "Fontify at least as far as bound.
-Leave point after last fontified position."
-  (unless bound (setq bound (point-max)))
-  (let (xmltok-dependent-regions
-	xmltok-errors)
-    (while (and (< (point) bound)
-		(nxml-tokenize-forward))
-      (nxml-clear-face xmltok-start (point))
-      (nxml-apply-fontify-rule))))
-
 ;; Vectors identify a substring of the token to be highlighted in some face.
 
 ;; Token types returned by xmltok-forward.
@@ -2582,13 +2626,7 @@
 	       (> (prefix-numeric-value arg) 0))))
     (when (not (eq new nxml-char-ref-extra-display))
       (setq nxml-char-ref-extra-display new)
-      (save-excursion
-	(save-restriction
-	  (widen)
-	  (if nxml-char-ref-extra-display
-	      (nxml-with-unmodifying-text-property-changes
-		(nxml-clear-fontified (point-min) (point-max)))
-	    (nxml-clear-char-ref-extra-display (point-min) (point-max))))))))
+      (font-lock-fontify-buffer))))
 
 (put 'nxml-char-ref 'evaporate t)
 

[-- Attachment #3: qtmstr-nxml-mode.el --]
[-- Type: text/plain, Size: 1137 bytes --]

;;;; Customization for nXML mode

(setq rng-schema-locating-files
      (append '("~/emacs/nxml-schema/schemas.xml")
              rng-schema-locating-files-default))

(defface nxml-template
  '((t (:bold t
        :foreground "blue"
        :background "#ddddff")))
  "Face used to highlight embedded template constructs"
  :group 'nxml-highlighting-faces)

(defun qtmstr-nxml-hook ()
  (when (string-match "\\.html$" buffer-file-name)
    (let ((py-prefix-re
           (regexp-opt
            '(
              "py:if"
              "py:choose"
              "py:when"
              "py:otherwise"
              "py:for"
              "py:def"
              "py:match"
              "py:with"
              "py:attrs"
              "py:content"
              "py:replace"
              "py:strip"))))

      (font-lock-add-keywords
       nil
       `(("\\$\\([a-zA-Z_][a-zA-Z0-9_]*\\)" 1
          'nxml-template prepend)

         ("\\${\\([^}\"]+\\)}" 1
          'nxml-template prepend)

         (,(concat py-prefix-re "=\"\\([^\"]*\\)\"") 1
          'nxml-template prepend))))))

(add-hook 'nxml-mode-hook #'qtmstr-nxml-hook)



[-- Attachment #4: genshi.rnc --]
[-- Type: text/plain, Size: 1265 bytes --]

namespace py = "http://genshi.edgewall.org/"

genshi.expr-type    = xsd:string { minLength = "1" }
genshi.with-type    = xsd:string { minLength = "1" }
genshi.choose-type  = xsd:string
genshi.def-type   = xsd:string
genshi.xpath-type = xsd:anyURI

genshi.attrib = attribute py:if        { genshi.expr-type   }?,
                attribute py:choose    { genshi.choose-type }?,
                attribute py:when      { genshi.expr-type   }?,
                attribute py:otherwise { genshi.expr-type   }?,
                attribute py:for       { genshi.expr-type   }?,
                attribute py:def       { genshi.def-type    }?,
                attribute py:match     { genshi.xpath-type  }?,
                attribute py:with      { genshi.with-type   }?,
                attribute py:attrs     { genshi.expr-type   }?,
                attribute py:content   { genshi.expr-type   }?,
                attribute py:replace   { genshi.expr-type   }?,
                attribute py:strip     { genshi.expr-type   }?

genshi.if.attlist   = attribute expr { genshi.expr-type }
genshi.for.attlist  = attribute each { genshi.expr-type }
genshi.def.attlist  = attribute each { genshi.expr-type }
genshi.with.attlist = attribute vars { genshi.with-type }

               

[-- Attachment #5: qtmstr-xhtml.rnc --]
[-- Type: text/x-c++src, Size: 2110 bytes --]

namespace py = "http://genshi.edgewall.org/"
namespace xi = "http://www.w3.org/2001/XInclude"

include "genshi.rnc"
include "xinclude.rnc"
include "../nxml/schema/xhtml.rnc"

start |= head|body|p|\div|h1|h2|h3|h4|h5|h6|hr|pre|dl|ol|ul|table|form

Common.attrib &= genshi.attrib
head.attlist  &= genshi.attrib
html.attlist  &= genshi.attrib

Head.class = base | isindex | link | meta | script | title | style |
             if-head | for-head | def-head | with-head

Head.model = Head.class*

head.content &= Head.model*

if-inline   = element py:if   { genshi.if.attlist, Inline.model }
if-block    = element py:if   { genshi.if.attlist, Block.model }
if-head     = element py:if   { genshi.if.attlist, Head.model }
for-inline  = element py:for  { genshi.for.attlist, Inline.model }
for-block   = element py:for  { genshi.for.attlist, Block.model }
for-head    = element py:for  { genshi.for.attlist, Head.model }
def-inline  = element py:def  { genshi.def.attlist, Inline.model }
def-block   = element py:def  { genshi.def.attlist, Block.model }
def-head    = element py:def  { genshi.def.attlist, Head.model }
with-inline = element py:with { genshi.with.attlist, Inline.model }
with-block  = element py:with { genshi.with.attlist, Block.model }
with-head   = element py:with { genshi.with.attlist, Head.model }

Inline.class |= if-inline | for-inline | def-inline | with-inline
Block.class  |= if-block | for-block | def-block | with-block

xi-inline = element xi:include {
                xinclude.include.attlist,
                element xi:fallback { genshi.attrib,
                    (xi-inline | Inline.model)*
                }?
            }

xi-block  = element xi:include { xinclude.include.attlist,
                element xi:fallback { genshi.attrib,
                    (xi-block | Block.model)*
                }?
            }

xi-head   = element xi:include { xinclude.include.attlist,
                element xi:fallback { genshi.attrib,
                    (xi-head | Head.model)*
                }?
            }

Inline.class |= xi-inline
Block.class  |= xi-block
Head.class   |= xi-head

[-- Attachment #6: schemas.xml --]
[-- Type: text/xml, Size: 136 bytes --]

<locatingRules xmlns="http://thaiopensource.com/ns/locating-rules/1.0">
  <typeId id="XHTML" uri="qtmstr-xhtml.rnc" />
</locatingRules>

[-- Attachment #7: xinclude.rnc --]
[-- Type: text/x-c++src, Size: 345 bytes --]

namespace xi = "http://www.w3.org/2001/XInclude"
namespace local = ""

xinclude.include.attlist =
    attribute href     { xsd:anyURI }?,
    attribute parse    { xsd:string }?,
    attribute xpointer { xsd:string }?,
    attribute encoding { xsd:string }?,
    attribute accept   { xsd:string }?,
    attribute accept-language { xsd:string }?


[-- Attachment #8: HelloWorldPage.html --]
[-- Type: text/html, Size: 184 bytes --]

^ permalink raw reply	[flat|nested] 24+ messages in thread
end of thread, other threads:[~2008-06-06 19:04 UTC | newest]

Thread overview: 24+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
     [not found] <200805231711.30830.danc@merrillpress.com>
2008-05-23 21:52 ` [patch] use font-lock Lennart Borgman (gmail)
2008-05-23 22:24   ` [emacs-nxml-mode] " Daniel Colascione
     [not found]   ` <200805231824.18563.danc@merrillpress.com>
2008-05-23 22:50     ` Lennart Borgman (gmail)
2008-05-24 15:03       ` Daniel Colascione
2008-05-24 16:57         ` Lennart Borgman (gmail)
2008-05-24  2:39   ` [emacs-nxml-mode] " Stefan Monnier
2008-05-23 22:26 Daniel Colascione
2008-05-24 20:38 ` Stefan Monnier
2008-05-25 20:36   ` Daniel Colascione
2008-05-26 14:52     ` Stefan Monnier
2008-05-27 15:13       ` Daniel Colascione
2008-05-27 15:37         ` Stefan Monnier
2008-05-27 15:45           ` Daniel Colascione
2008-05-27 18:37             ` Stefan Monnier
     [not found]             ` <jwv8wxj8pf9.fsf-monnier+emacs@gnu.org>
2008-06-05 23:07               ` Daniel Colascione
2008-06-05 23:30                 ` Lennart Borgman (gmail)
2008-06-06  7:01                 ` Stefan Monnier
2008-06-06  7:24                   ` Lennart Borgman (gmail)
2008-06-06  7:59                     ` Stefan Monnier
2008-06-06  8:09                       ` Lennart Borgman (gmail)
2008-06-06 10:09                         ` Jason Rumney
2008-06-06 14:23                         ` Chong Yidong
2008-06-06 19:04                       ` Richard M Stallman
2008-06-06 16:25                   ` Michael Olson

Code repositories for project(s) associated with this public inbox

	https://git.savannah.gnu.org/cgit/emacs.git

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).