Nested Regexp's

[Thorsten Jolitz]

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

[Doug Lewan]

> -----Original Message-----
> From: help-gnu-emacs-bounces+dougl=shuberttic...@gnu.org
> [mailto:help-gnu-emacs-bounces+dougl=shuberttic...@gnu.org] On
> Behalf Of Thorsten Jolitz
> Sent: Tuesday, 2012 September 18 12:41
> To: help-gn...@gnu.org
> Subject: Nested Regexp's
>
>
> Hi List,
>
> I'm somehow stuck with a regexp I need for fontification purposes.

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)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

[Thorsten Jolitz]

Doug Lewan <do...@shubertticketing.com> writes:

Hi Doug,

> 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.

thank you very much, very helpfull, exactly what I needed to tackle the
problem!

--
cheers,
Thorsten