lookahead

I am having problems with the nested '+'/'-' lookahead/lookbehind in regex. Let's say that I want to change the '*' in a string with '%' and let's say that '\' escapes the next character. (Turning a regex to sql like command ^^). So the string '*test*' should be changed to '%test%' , '\\*test\\*' -> '\\%test\\%' , but '\*test\*' and '\\\*test\\\*' should stay the same. I tried: (?<!\\)(?=\\\\)*\* but this doesn't work (?<!\\)((?=\\\\)*\*) ... (?<!\\(?=\\\\)*)\* ... (?=(?<!\\)(?=\\\\)*)\* ... What is the correct regex that will match the '*'s in examples given above? What is the difference

I'm writing a simple stack-based language in C and was wondering how I should go about implementing a loop structure of some kind, and/or lookahead symbols. Since the code is a bit long for this page (over 200 lines) I've put it in a GitHub repository . EDIT: The main program is in file stack.c . EDIT: The code just takes in input in words , kind of like FORTH. It uses scanf and works left to right. Then it uses a series of if s and strcmp s to decide what to do. That's really it. The Forth approach is to add a separate loop stack alongside the data stack. You then define operations that work

I have a string that contains sequences delimited by multiple characters: << and >> . I need a regular expression to only give me the innermost sequences. I have tried lookaheads but they don't seem to work in the way I expect them to. Here is a test string: 'do not match this <<but match this>> not this <<BUT NOT THIS <<this too>> IT HAS CHILDREN>> <<and <also> this>>' It should return: but match this this too and <also> this As you can see with the third result, I can't just use /<<[^>]+>>/ because the string may have one character of the delimiters, but not two in a row. I'm fresh out of

Im trying to do something fairly simple with regular expression in python... thats what i thought at least. What i want to do is matching words from a string if its preceded and followed by a whitespace. If its at the beginning of the string there is no whitespace required before - if its at the end, dont't search for whitespace either. Example: "WordA WordB WordC-WordD WordE" I want to match WordA WordB WordE . I only came up with overcomplicated way of doing this... (?<=(?<=^)|(?<=\s))\w+(?=(?=\s)|(?=$)) It seems to me there has to be a simple way for such a simple problem.... I figured i

How to match any character which repeats n times? Example: for input: abcdbcdcdd for n=1: .......... for n=2: ......... for n=3: .. ..... for n=4: . . .. for n=5: no matches After several hours my best is this expression (\w)(?=(?:.*\1){n-1,}) //where n is variable which uses lookahead. However the problem with this expression is this: for input: abcdbcdcdd for n=1 .......... for n=2 ... .. . for n=3 .. . for n=4 . for n=5 no matches As you can see, when lookahead matches for a character, let's look for n=4 line, d 's lookahead assertion satisfied and first d matched by regex. But remaining d

For the past few hours I've been trying to match address(es) from the following sample data and I can't get it to work: medicalHistory None address 24 Lewin Street, KUBURA, NSW, Australia email MaryBeor@spambob.com address 16 Yarra Street, LAWRENCE, VIC, Australia name Mary Beor medicalHistory None phone 00000000000000000000353336907 birthday 26-11-1972 My plan was to find anything that starts with "address", is followed by any space followed by characters, numbers commas and newlines and ends with newline followed by a character. I came up with the following (and many variations of it):

I got StackOverflowError when matching the result using a RegEx pattern. The pattern is (\d\*?(;(?=\d))?)+ . This regex is used to validate the input: 12345;4342;234*;123*;344324 The input is a string consists of values (only digits) separated by ; . Each value could include one * at the end (used as wildcard for other matching). There is no ; at the end of the string. The problem is that this regex works fine which small number of values. But when the numbers of values is too large (over 300), it will cause StackOverflowError . final String TEST_REGEX = "(\\d\\*?(;(?=\\d))?)+"; // Generate

This question is inspired by this other one . Comparing s/,(\d)/$1/ to s/,(?=\d)// : the former uses a capture group to replace only the digit but not the comma, the latter uses a lookahead to determine whether the comma is succeeded by a digit. Why is the latter sometimes faster, as discussed in this answer ? The two approaches do different things and have different kinds of overhead costs. When you capture, perl has to make a copy of the captured text. Look-ahead matches without consuming; it has to mark the location where it starts. You can see what's happening by using the re 'debug'