AutoHotkey Community

Hi, folks,

I've found a nasty regular expression and I was wondering if I could get some help decoding it. All of the ?Ps have got me freaking out. Here's the expression:

It's from ISense and I've been working on it for about half an hour. It parses segments of code that start at the beginning of a line of code and end in the middle of it.

What I've already figured out:

* I know that <Ignore>, <found>, etc., match subexpressions which are accessed later through the output array of RegExMatch().
* I know that the RE is divided into three sections, separated by | and that it only has to match one section. I suspect that each section represents a syntax: perhaps one is for functions, one is for expressions, etc., but I don't know which is which.

What I don't know:

* what the ?s are for. There seem to be two types... those preceding a P and those not. I'm not sure what either do.
*How the ?&%$! thing works!

JoeSchmoe

The original code follows. The function receives a snippet of code as an argument. The snippet of code generally starts at the beginning of a line, but can end in the middle of it.



Bonus question: what does the " mIgnore ? ( pSel := mStart . mEnd )" line do? It doesn't look like valid syntax.

As a matter of fact, I remember doing that.. and I'll have u know I was freaking out! But- nasty!??

After tonight and the inevidable recovery tomorrow, I will post some detailed explantions for you, as well as respond to ur post on the other thread.

_________________
.o0[ corey ]0o.

So here goes nothing....

You got it. This function is what re-evaluates the current line your cursor is on when you press your assigned hotkey, so it can display contextual parameter assistance. It captures from the beginning of line to your current cursor position, and passes as pSel var as a parameter to function.


Lets start with a simple example: A legacy AHK command (non-function)


Breaking down the regex,
There is a capturing subpattern for the entire match, & then two subpatterns within to capture the beginning command, and the parameters.
The ? is there means that the ',' is optional-- & isn't required to be considered a match.


What makes the regex seem more complicated looking is that I am using named subpatterns. After you get used to using them, they actually make the pattern easier to translate (at least for me anyway.. )
So looking at the example above, you are feeding MsgBox, 48, title, text| through pSel param (the '|' represents your current cursor position). When performing the regex, your named subpatterns are captured and used to pull up msgbox's parameter help (3rd param is the active one..)

Now for the next example: Functions

Breaking down the regex again,

• Entire match
• Command
• Paramaters

In this case, the optional subpattern is captured-- basically just to discard. Try setting pSel to RegExMatch( SubStr( string| to see what I mean..

Since the function will break from the loop as soon as it finds a pattern, we have to put this pattern before the previous one in our regex since it has more specific criteria to be a match.

Now, some questions you probably have:

• What happened to the loop, & whats the point of it?
• Whats mIgnore ? ( pSel := mStart . mEnd )

Consider this example:

When you re-evaluate line, you want to see the 3rd parameter for regexmatch. The substr call in there is irrelevant, & will do nothing but confuse your parameter count. For this reason, the loop will collapse these complete function calls-- discarding params that will throw everything off.

Again- the regex..

• Entire match
• Beginning of line: Everything up to the '('
• Ending of line: Everything after the ')'

The \((?U).*(?-U)\) can be interpreted as-- everything between the parenthesis. (?U) is just making this portion of the pattern ungreedy.



This is a ternary expression. It is a shorthand way of writing:

So within the loop, since the first time through it will find a 'mIgnore' match, it changes pSel var from RegExMatch( SubStr(string, 1, 15), re, var| to RegExMatch( SubStr, re, var|

I've tweaked the code some more in the repo:
Let me know any specific AHK cases you see an issue with (I'm sure there are still some..) either on this thread, or via PM.

So maybe it is nasty (<--lol), but for me its a lot easier to read than a whole bunch of if / else / and / or / but / whatever's.
Using this technique will make this function fairly simple to adapt for use in any language, which is one of the overall goals for this project. It all comes down to loading a variable containing your language's RE.

_________________
.o0[ corey ]0o.