Regular expression of a string that starts with a letter followed by only letters and digits except two specific strings in lex

Question

I am trying to write the regular expression of a string that has the characteristics mentioned above. Here, the specific strings are "true" and "false". For example:"d6" will be accepted but "6d" won't. Also "true" and "false" won't be accepted. I have googled a lot, got various examples but still can't make it. Please help.

Answer 1

If you are really planning on using lex (or flex), then you need to match the keywords with separate rules.

Remember that (f)lex applies the maximal munch rule: at each point in the input, the token matched is the longest possible match of all patterns, so the rule attached to the pattern with the longest match is performed. Furthermore, if two or more different patterns both produce the same longest match, the first one in the file wins.

So this is how you match identifiers other than true or false:

false   { /* Action for the keyword false */ }
true    { /* Action for the keyword true */ }
[[:alpha:]][[:alnum:]]* {
          /* Action for all other identifiers */
        }

If you also wanted to match integers, you could add:

[[:digit:]]+ {
          /* Action for integers */
        }

That will not produce an error for a token like 6d. There are good reasons to treat that as two tokens rather than produce an error (see, for example, the discussion in this answer), but if you really want to treat it as an error, you can add an error pattern:

[[:digit:]]+[[:alpha:]][[:alnum:]]* {
          /* Action for tokens which start with a digit and contain a letter */
        } 

The Posix character classes used above ([[:digit:]] and so on) are documented in the flex manual chapter on patterns.

Answer 2

I think the below regex would meet your requirements:

/(?!.*(true|false))^[a-zA-Z]+[a-zA-Z0-9]*$/

The details on the above Regex are:

• Firstly, there should not be string 'true' or 'false' in the whole string which is (?!.*(true|false)) this is a negative lookahead which means nothing followed by values true or false is allowed.You can read more about the lookahead from here.

• Secondly, it should start with a character so we have ^[a-zA-Z]+

• Lastly, there can be any number of charcters and numbers in the rest string and then end is matched by [a-zA-Z0-9]*$.

Hope this solves your problem.

Answer 3

Your conditions are

I just want to match any string starts with a letter followed by letters and digits.

This can be achieved with ^[a-zA-Z][a-zA-Z0-9]+$

But if the string is "true" or "false", that won't be accepted.

This is the trickier part, it seems lex does not support negative lookahead or positive/negative lookbehind. so we're stuck only with positive lookahead.

This regex solves the problem with positive lookahead

^(?=[^tf]|t[^r]|tr[^u]|true[a-zA-Z0-9]|f[^a]|fa[^l]|fal[^s]|false[a-zA-Z0-9])[a-zA-Z][a-zA-Z0-9]+$

the lookahead part is ^(?=[^tf]|t[^r]|tr[^u]|true[a-zA-Z0-9]|f[^a]|fa[^l]|fal[^s]|false[a-zA-Z0-9])

it expects the next string is not true or false. it allows truer, falsetto etc preventing only true and false.

The problem is I can't find a way to right this in lex format. as lex doesn't use the (?=) syntax. It uses r1/r2 syntax where r1 is matched if it is followed by r2. In our case we want to capture r2 if r1 is true.

I hope someone else continue converting this to proper lex format

the demo for the given regex can be found here