Hi List,

I'm somehow stuck with a regexp I need for fontification purposes.

This is the syntax:

,--------------------
| -{bar}  ; list item
| !{foo}  ; bold
`--------------------

These are examples of nesting bold text into list items:

,-------------------------------------------------------------------
| -{foo bar foo bar}            ; fontified as list item
| -{!{bold} foo bar}            ; bold fontified, list item text not
| -{foo bar                     ; fontified as list item
|    foo bar}
| -{foo bar !{hello             ; 'hello bold' fontified, list item text not
|    bold} foo bar}
`-------------------------------------------------------------------

These are the regexps:

,--------------------------------------------------
| (defconst my-regex-list-item
|   "\\(-{\\)\\([        
| ]*[^}]+\\)\\(}\\)"
|   "Regular expression for matching a list item.")
|
| (defconst my-regex-bold
|   "\\(!{\\)\\([        
| ]*[^}]+\\)\\(}\\)"
|   "Regular expression for matching bold text.")
`--------------------------------------------------

Now I would need to construct a 'my-regex-list-item' that allows for one
or several nested 'bold' terms, with each the list item and the bold term
possibly including line-breaks. The result should actually show the
whole list item in the assigned color, and the bold terms in the same
color, but bold.

I would appreciate any hint about how to construct the list-item regexp
in a way that it can contain nested bold terms.

--
cheers,
Thorsten

It helps me a lot to think of regular expressions like programs and therefore to structure them like programs.

Here's how I define the REs that I think you want. (I assume that by "nested" you mean multiple.) I hope this helps.

,Doug

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defconst my-regex-plain-text
  (concat "\\([[:space:]]*[^}]+\\)[[:space:]]*" ; Matches "123$%^ þÅÂÕÒÁÛËÁ &*(0-="
          )
  "Regular expression defining what 'plain text' is.")

(defconst  my-regex-bold-text
  (concat "\\(!{\\)"
          my-regex-plain-text
          "\\(}\\)")
  "Regular expression defining what 'bold text' is.")

(defconst my-regex-text
  (concat "\\("
          my-regex-plain-text
          "\\|"
          my-regex-bold-text
          "\\)")
  "Regular expression defining what 'text'.
Text is a mix of plain text and bold text.")

(defconst my-regex-list-item
  (concat "\\(-{\\)"
          my-regex-text "+"
          "\\(}\\)")
  "Regular expression defining what a 'list item' is.")

;;
;; Sunny day test code
;;
(defconst test-plain-text (list "foo"
                                "foo bar "
                                "  foo bar baz bat"
                                " --- 123$%^ þÅÂÕÒÁÛËÁ &*(0-= --- "))
(defconst test-bold-text (mapcar (lambda (text)
                                   (concat "!{" text "}"))
                                 test-plain-text))
(defconst test-list-item (mapcar (lambda (list-text)
                                   (concat "-{" list-text "}"))
                                 (append test-plain-text test-bold-text)))

(mapc (lambda (test-spec)
        (let ((re (car test-spec))
              (test-data (cdr test-spec)))
          (mapc (lambda (item)
                  (if (string-match re item)
                      (message "PASS -- [[%s]] matches [[%s]]" re item)
                    (message "FAIL -- [[%s]] DIDN'T match [[%s]]" re item))
                  (sit-for 1))
                test-data)))
      (list (cons my-regex-plain-text test-plain-text)
            (cons my-regex-bold-text test-bold-text)
            (cons my-regex-list-item test-list-item)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

--
cheers,
Thorsten