On 1.10.2013, at 20:36, Thorsten Jolitz <tjolitz@gmail.com> wrote:

> Carsten Dominik <carsten.dominik@gmail.com> writes:
> 
>> On 1.10.2013, at 19:50, Thorsten Jolitz <tjolitz@gmail.com> wrote:
>> 
>>> 
>>> Hi List,
>>> 
>>> for the navi-mode keyword-search for complete property drawers I copied
>>> 
>>> ,-----------------------
>>> | org-property-drawer-re
>>> `-----------------------
>>> 
>>> from org.el:
>>> 
>>> #+begin_src emacs-lisp
>>> (concat "\\(" org-property-start-re "\\)[^\000]*\\("
>>> 	  org-property-end-re "\\)\n?")
>>> #+end_src
>>> 
>>> #+results:
>>> : \(^[ 	]*:PROPERTIES:[ 	]*$\)[^\\000]*\(^[ 	]*:END:[ 	]*$\)
>>> : ?
>>> 
>>> A bit unreadable, but you get the message ... here is my hopefully equivalent
>>> version:
>>> 
>>> ,--------------------------------------------------------------
>>> | (:propertydrawer
>>> |   . (concat "\\(^[\\s\\t]*:PROPERTIES:[\\s\\t]*$\\)[^\\000]*"
>>> |             "\\(^[\\s\\t]*:END:[\\s\\t]*$\\)\\n?"))
>>> `--------------------------------------------------------------
>>> 
>>> But this did not match correctly in Bernt Hansens tutorial:
>> 
>> Indeed, this is a bad regular expression, it is too greedy and will
>> match all the way to the last :END: line it can find.  also, \\s is
>> wrong, it should be just a space, so "[ \t]". Luckily
>> this regular expression does not seem to be used in Org as far
>> as I can see....
> 
> 
> But, if this is equivalent to the #+results: block above, it is defined
> in org.el without that one ? indicated that makes the difference:
> 
> ,-----------------------------------------------------------
> | (:propertydrawer
> |   . (concat "\\(^[ \\t]*:PROPERTIES:[ \\t]*$\\)[^\\000]*?" <=
> |             "\\(^[ \\t]*:END:[ \\t]*$\\)\\n?"))
> `-----------------------------------------------------------

Yes.  this is a bug, fortunately inconsequential since org does
its property matching in a different way.

Anyway, this bug is fixed in master.

- Carsten

> 
>> Yes, you need the star to make it non-greedy.
> 
> the '?' I guess ...
> 
>> However, you can leave the \n after you have corrected the
>> character class to "[ \t]" - it just means that
>> the \n will be part of the match, but still allow
>> for the possibility that the last line hits the end
>> of the buffer.
> 
> ok, I see
> 
>> Ahhhh, regular expressions.  I think in my entire history
>> as a programmer, learning about regular expressions was
>> the biggest braintrip I ever had - still love them.
> 
> thanks god for M-x regexp-builder ;)
> 
>>> PS
>>> Can anybody explain this marvelous construct in the regexp:
>>> 
>>> ,---------
>>> | [^\\000]
>>> `---------
>> 
>> This is just a cheep way to match any character at all, because \000 should
>> not be part of any string (in C it indicates the end of a string).
>> In principle you could put any character you are sure will not turn up,
>> but \000 seems to be the safest choice.  It is
>> faster (I think) than "\\(.\\|\n\\)*" because the first will
>> just run fast and streight with a table lookup while the
>> latter need to always alternate between two alternatives.
>> I have not timed it, though.
> 
> This is a very nice trick, and the alternative looks easy too - I have
> to remember this.
> 
>>> I often pondered about how to achieve its effect with other means, since
>>> I did not find it in the Emacs Lisp manual.
>> 
>> There you go - sometimes a brain is better than the Emacs manual :)
> 
> Thanks a lot
> 
> --
> cheers,
> Thorsten
> 
>