es = ''

l = len(s)

i=0

#escaped_re = /([.*+?^${}()|[\]\/\\\-])/g

if chargroup:

while i < l:

c = s[i]

i += 1

es += (esc if ('-' == c) or ('^' == c) or ('$' == c) or ('|' == c) or ('{' == c) or ('}' == c) or ('(' == c) or (')' == c) or ('[' == c) or (']' == c) or ('/' == c) or (esc == c) else '') + c

else:

while i < l:

c = s[i]

i += 1

es += (esc if ('?' == c) or ('*' == c) or ('+' == c) or ('.' == c) or ('^' == c) or ('$' == c) or ('|' == c) or ('{' == c) or ('}' == c) or ('(' == c) or (')' == c) or ('[' == c) or (']' == c) or ('/' == c) or (esc == c) else '') + c

if p2:

if is_array(p2):

for p in p2: p1[ p ] = 1

else:

for p in p2: p1[ p ] = 1;

if first and is_array(first):

last = first[1]

first = first[0]

start = ord(first[0])

end = ord(last[0])

if end == start: return [ chr( start ) ]

chars = []

for ch in range(start, end+1, 1):

chars.append(chr( ch ))

specialChars = {

"." : "MatchAnyChar",

"|" : "MatchEither",

"?" : "MatchZeroOrOne",

"*" : "MatchZeroOrMore",

"+" : "MatchOneOrMore",

"^" : "MatchStart",

"$" : "MatchEnd",

"{" : "StartRepeats",

"}" : "EndRepeats",

"(" : "StartGroup",

")" : "EndGroup",

"[" : "StartCharGroup",

"]" : "EndCharGroup"

}

specialCharsEscaped = {

"\\" : "ESC",

"/" : "/",

"0" : "NULChar",

"f" : "FormFeed",

"n" : "LineFeed",

"r" : "CarriageReturn",

"t" : "HorizontalTab",

"v" : "VerticalTab",

"b" : "MatchWordBoundary",

"B" : "MatchNonWordBoundary",

"s" : "MatchSpaceChar",

"S" : "MatchNonSpaceChar",

"w" : "MatchWordChar",

"W" : "MatchNonWordChar",

"d" : "MatchDigitChar",

"D" : "MatchNonDigitChar"

}

BSPACES = BSPACES

SPACES = SPACES

PUNCTS = PUNCTS

DIGITS = DIGITS

DIGITS_RANGE = DIGITS_RANGE

HEXDIGITS_RANGES = HEXDIGITS_RANGES

ALPHAS = ALPHAS

def __init__(self, regex):

self.re = regex

self.len = len(regex)

self.pos = 0

self.index = 0

self.groupIndex = 0

self.group = {}

self.inGroup = 0

def dispose(self):

self.re = None

self.len = None

self.pos = None

self.index = None

self.groupIndex = None

self.group = None

self.inGroup = None

def __del__(self):

def toObjectStatic( v ):

if isinstance(v,Node):

return {

'type': v.typeName,

'value': Node.toObjectStatic(v.val),

'flags': v.flags

} if v.flags and len(v.flags) else {

'type': v.typeName,

'value': Node.toObjectStatic(v.val)

}

elif is_array(v):

return list(map(Node.toObjectStatic, v))

return v

def __init__(self, type, value, flags=None):

self.type = type

self.val = value

self.flags = flags if flags else {}

if T_SEQUENCE == type:

self.typeName = "Sequence"

elif T_ALTERNATION == type:

self.typeName = "Alternation"

elif T_GROUP == type:

self.typeName = "Group"

elif T_CHARGROUP == type:

self.typeName = "CharacterGroup"

elif T_CHARS == type:

self.typeName = "Characters"

elif T_CHARRANGE == type:

self.typeName = "CharacterRange"

elif T_STRING == type:

self.typeName = "String"

elif T_QUANTIFIER == type:

self.typeName = "Quantifier"

elif T_UNICODECHAR == type:

self.typeName = "UnicodeChar"

elif T_HEXCHAR == type:

self.typeName = "HexChar"

elif T_SPECIAL == type:

self.typeName = "Special"

elif T_COMMENT == type:

self.typeName = "Comment"

else: self.typeName = "unspecified"

def __del__(self):

self.dispose()

def dispose(self):

self.val = None

self.flags = None

self.type = None

self.typeName = None

return self

def toObject(self):

#if maxlen < 0: maxlen = float("inf")

lp = pos

l = 0

sl = len(s)

while (lp < sl) and (l <= maxlen) and (s[lp] in CHARS):

lp+=1

l+=1

#if maxlen < 0: maxlen = float("inf")

lp = pos

l = 0

sl = len(s)

found = True

while (lp < sl) and (l <= maxlen) and found:

ch = ord(s[lp])

if ch >= RANGE[0] and ch <= RANGE[1]:

lp+=1

l+=1

else: found = False

#if maxlen < 0: maxlen = float("inf")

lp = pos

l = 0

sl = len(s)

found = True

while (lp < sl) and (l <= maxlen) and found:

ch = ord(s[lp])

found = False

for RANGE in RANGES:

if ch >= RANGE[0] and ch <= RANGE[1]:

lp+=1

l+=1

found = True

break

global _G

if positive is not False:

return _G.SPACES[rnd(0, len(_G.SPACES)-1)]

else:

global _G

if positive is not False:

return _G.DIGITS[rnd(0, len(_G.DIGITS)-1)]

else:

global _G

if positive is not False:

return _G.ALPHAS[rnd(0, len(_G.ALPHAS)-1)]

else:

global _G

if positive is not False:

s = _G.ALPHAS+_G.DIGITS

return s[rnd(0, len(s)-1)]

else:

global _G

if positive is not False:

l = len(chars)

return chars[rnd(0, l-1)] if l else ''

else:

choices = []

for choice in _G.ALL:

if choice not in chars: choices.append(choice)

l = len(choices)

if asArray:

if isinstance(chars, str): chars = chars.split('')

chars = list(map( random_upper_or_lower, chars ))

return chars

else:

if (node is None) or (not state): return ret

type = node.type if isinstance(node, Node) else None

# walk the tree

if type is None:

# custom, let reduce handle it

ret = state['reduce']( ret, node, state )

elif state['IGNORE'] & type:

# nothing

pass

elif state['MAP'] & type:

r = state['map']( ret, node, state )

if ('ret' in state) and (state['ret'] is not None):

ret = state['reduce']( ret, node, state )

state['ret'] = None

elif r is not None:

r = array(r)

for ri in r:

state['node'] = node

ret = walk( ret, ri, state )

if ('stop' in state) and state['stop']:

state['stop'] = None

return ret

elif state['REDUCE'] & type:

ret = state['reduce']( ret, node, state )

state['node'] = None

type = node.type

if T_ALTERNATION == type:

r = []

l = len(node.val)-1

for i in range(l):

r.append(node.val[i])

r.append('|')

r.append(node.val[l])

return r

elif T_CHARGROUP == type:

return ['['+('^' if 'NegativeMatch' in node.flags else '')] + array(node.val) + [']']

elif T_QUANTIFIER == type:

q = ''

if 'MatchZeroOrOne' in node.flags: q = '?'

elif 'MatchZeroOrMore' in node.flags: q = '*'

elif 'MatchOneOrMore' in node.flags: q = '+'

else: q = ('{'+str(node.flags['min'])+'}') if node.flags['min'] == node.flags['max'] else ('{'+str(node.flags['min'])+','+('' if -1==node.flags['max'] else str(node.flags['max']))+'}')

if (node.flags['min'] != node.flags['max']) and not node.flags['isGreedy']: q += '?'

return array(node.val) + [q]

elif T_GROUP == type:

g = None

if 'NotCaptured' in node.flags:

g = ['(?:'] + array(node.val) + [')']

elif 'LookAhead' in node.flags:

g = ['(?='] + array(node.val) + [')']

elif 'NegativeLookAhead' in node.flags:

g = ['(?!'] + array(node.val) + [')']

elif 'LookBehind' in node.flags:

g = ['(?<='] + array(node.val) + [')']

elif 'NegativeLookBehind' in node.flags:

g = ['(?<!'] + array(node.val) + [')']

else:

g = ['('] + array(node.val) + [')']

if 'GroupIndex' in node.flags:

ret['group'][str(node.flags['GroupIndex'])] = node.flags['GroupIndex']

if 'GroupName' in node.flags: ret['group'][node.flags['GroupName']] = node.flags['GroupIndex']

return g

type = node.type

if (T_ALTERNATION == type) or (T_CHARGROUP == type):

return node.val[rnd(0, len(node.val)-1)] if len(node.val) else None

elif T_QUANTIFIER == type:

if len(ret) >= state['maxLength']:

numrepeats = node.flags['min']

else:

mmin = node.flags['min']

mmax = (mmin+1+2*state['maxLength']) if -1==node.flags['max'] else node.flags['max']

numrepeats = rnd(mmin, mmax)

return [node.val] * numrepeats if numrepeats else None

elif (T_GROUP == type) and ('GroupIndex' in node.flags):

sample = walk('', node.val, state)

state['group'][str(node.flags['GroupIndex'])] = sample

state['ret'] = sample

return None

else:

type = node.type

if T_ALTERNATION == type:

l = len(node.val)

min = walk(0, node.val[0], state) if l else 0

i = 1

while i < l:

cur = walk(0, node.val[i], state)

if cur < min: min = cur

i += 1

if l: state['ret'] = min

return None

elif T_CHARGROUP == type:

return node.val[0] if len(node.val) else None

elif T_QUANTIFIER == type:

if 0==node.flags['min']: return None

return [node.val] * node.flags['min']

elif (T_GROUP == type) and ('GroupIndex' in node.flags):

min = walk(0, node.val, state)

state['group'][str(node.flags['GroupIndex'])] = min

state['ret'] = min

return None

else:

type = node.type

if T_ALTERNATION == type:

l = len(node.val)

max = walk(0, node.val[0], state) if l else 0

if -1 != max:

i = 1

while i<l:

cur = walk(0, node.val[i], state)

if -1 == cur:

max = -1

break

elif cur > max:

max = cur

i += 1

if l: state['ret'] = max

return None

elif T_CHARGROUP == type:

return node.val[0] if len(node.val) else None

elif T_QUANTIFIER == type:

max = walk(0, node.val, state)

if -1 == max:

state['ret'] = -1

elif 0 < max:

if -1 == node.flags['max']:

state['ret'] = -1

elif 0 < node.flags['max']:

state['ret'] = node.flags['max']*max

else:

state['ret'] = max

return None

elif (T_GROUP == type) and ('GroupIndex' in node.flags):

max = walk(0, node.val, state)

state['group'][str(node.flags['GroupIndex'])] = max

state['ret'] = max

return None

else:

type = node.type

if T_SEQUENCE == type:

seq = []

for n in node.val:

seq.append( n )

if (T_QUANTIFIER == n.type) and (0 == n.flags['min']):

continue

elif (T_SPECIAL == n.type) and (('MatchStart' in n.flags) or ('MatchEnd' in n.flags)):

continue

break

return seq if len(seq) else None

else:

if ('ret' in state) and state['ret'] is not None:

if -1 == state['ret']: ret = -1

else: ret += state['ret']

return ret

if -1 == ret: return ret

if isinstance(node, int):

ret += node

return ret

if (T_SPECIAL == node.type) and ('MatchEnd' in node.flags):

state['stop'] = 1

return ret

type = node.type;

if (T_CHARS == type) or (T_CHARRANGE == type) or (T_UNICODECHAR == type) or (T_HEXCHAR == type) or ((T_SPECIAL == type) and ('MatchStart' not in node.flags) and ('MatchEnd' not in node.flags)):

ret += (state['group'][node.val] if node.val in state['group'] else 0) if 'BackReference' in node.flags else 1

elif T_STRING == type:

ret += len(node.val)

if ('ret' in state) and state['ret'] is not None:

ret += str(state['ret'])

return ret

if is_string(node):

ret += node

return ret

if (T_SPECIAL == node.type) and ('MatchEnd' in node.flags):

state['stop'] = 1

return ret

type = node.type

sample = None

if T_CHARS == type:

sample = node.val

elif T_CHARRANGE == type:

range = [node.val[0],node.val[1]]

if isinstance(range[0],Node) and (T_UNICODECHAR == range[0].type or T_HEXCHAR == range[0].type): range[0] = range[0].flags['Char']

if isinstance(range[1],Node) and (T_UNICODECHAR == range[1].type or T_HEXCHAR == range[1].type): range[1] = range[1].flags['Char']

sample = character_range(range)

elif (T_UNICODECHAR == type) or (T_HEXCHAR == type):

sample = [node.flags['Char']]

elif (T_SPECIAL == type) and ('MatchStart' not in node.flags) and ('MatchEnd' not in node.flags):

part = node.val

if 'BackReference' in node.flags:

ret += state['group'][part] if part in state['group'] else ''

return ret

elif 'D' == part: sample = [digit( False )]

elif 'W' == part: sample = [word( False )]

elif 'S' == part: sample = [space( False )]

elif 'd' == part: sample = [digit( )]

elif 'w' == part: sample = [word( )]

elif 's' == part: sample = [space( )]

elif ('.' == part) and ('MatchAnyChar' in node.flags): sample = [any( )]

else: sample = [ESC + part]

elif T_STRING == type:

sample = node.val

if sample is not None:

ret += (case_insensitive(sample) if state['isCaseInsensitive'] else sample) if T_STRING == type else character(case_insensitive(sample, True) if state['isCaseInsensitive'] else sample, ('node' not in state) or ('NegativeMatch' not in state['node'].flags))

if ('ret' in state) and state['ret'] is not None:

if 'src' in statep['ret']: ret['src'] += state['ret']['src']

if 'group' in state['ret']: ret['group'].update(state['ret']['group'])

return ret

if is_string(node):

ret['src'] += node

return ret

type = node.type

if T_CHARS == type:

ret['src'] += esc_re(''.join(node.val), ESC, 1) if state['escaped'] else ''.join(node.val)

elif T_CHARRANGE == type:

range = [node.val[0],node.val[1]]

if state['escaped']:

if isinstance(range[0],Node) and T_UNICODECHAR == range[0].type: range[0] = ESC+'u'+pad(range[0].flags['Code'],4)

elif isinstance(range[0],Node) and T_HEXCHAR == range[0].type: range[0] = ESC+'x'+pad(range[0].flags['Code'],2)

else: range[0] = esc_re(range[0], ESC, 1)

if isinstance(range[1],Node) and T_UNICODECHAR == range[1].type: range[1] = ESC+'u'+pad(range[1].flags['Code'],4)

elif isinstance(range[1],Node) and T_HEXCHAR == range[1].type: range[1] = ESC+'x'+pad(range[1].flags['Code'],2)

else: range[1] = esc_re(range[1], ESC, 1)

else:

if isinstance(range[0],Node) and (T_UNICODECHAR == range[0].type or T_HEXCHAR == range[0].type): range[0] = range[0].flags['Char']

if isinstance(range[0],Node) and (T_UNICODECHAR == range[1].type or T_HEXCHAR == range[1].type): range[1] = range[1].flags['Char']

ret['src'] += range[0]+'-'+range[1]

elif T_UNICODECHAR == type:

ret['src'] += ESC+'u'+pad(node.flags['Code'],4) if state['escaped'] else node.flags['Char']

elif T_HEXCHAR == type:

ret['src'] += ESC+'x'+pad(node.flags['Code'],2) if state['escaped'] else node.flags['Char']

elif T_SPECIAL == type:

if 'BackReference' in node.flags:

ret['src'] += ESC+node.val

else:

ret['src'] += (''+node.val) if ('MatchAnyChar' in node.flags) or ('MatchStart' in node.flags) or ('MatchEnd' in node.flags) else (ESC+node.val)

elif T_STRING == type:

ret['src'] += esc_re(node.val, ESC) if state['escaped'] else node.val

if ('ret' in state) and state['ret'] is not None:

ret['positive'] = concat( ret['positive'], state['ret']['positive'] )

ret['negative'] = concat( ret['negative'], state['ret']['negative'] )

return ret

if (T_SPECIAL == node.type) and ('MatchEnd' not in node.flags):

state['stop'] = 1

return ret

type = node.type

inCharGroup = ('node' in state) and (T_CHARGROUP == state['node'].type)

inNegativeCharGroup = inCharGroup and ('NotMatch' in state['node'].flags)

peek = "negative" if inNegativeCharGroup else "positive"

if T_CHARS == type:

ret[peek] = concat( ret[peek], node.val )

elif T_CHARRANGE == type:

range = [node.val[0],node.val[1]]

if isinstance(range[0],Node) and (T_UNICODECHAR == range[0].type or T_HEXCHAR == range[0].type): range[0] = range[0].flags['Char']

if isinstance(range[1],Node) and (T_UNICODECHAR == range[1].type or T_HEXCHAR == range[1].type): range[1] = range[1].flags['Char']

ret[peek] = concat( ret[peek], character_range(range) )

elif (T_UNICODECHAR == type) or (T_HEXCHAR == type):

ret[peek][node.flags['Char']] = 1

elif (T_SPECIAL == type) and ('BackReference' not in node.flags) and ('MatchStart' not in node.flags) and ('MatchEnd' not in node.flags):

part = node.val

if 'D' == part:

ret["positive" if inNegativeCharGroup else "negative"][ '\\d' ] = 1

elif 'W' == part:

ret["positive" if inNegativeCharGroup else "negative"][ '\\w' ] = 1

elif 'S' == part:

ret["positive" if inNegativeCharGroup else "negative"][ '\\s' ] = 1

elif 'B' == part:

ret["positive" if inNegativeCharGroup else "negative"][ '\\b' ] = 1

else:

ret[peek][ESC + part] = 1

elif T_STRING == type:

ret["positive"][node.val[0]] = 1

global _G

m = False

if (len(s) > 2) and ('x' == s[0]):

if match_char_ranges(_G.HEXDIGITS_RANGES, s, 1, 2, 2):

m=s[0:3]

return [m, m[1:]]

global _G

m = False

if (len(s) > 4) and ('u' == s[0]):

if match_char_ranges(_G.HEXDIGITS_RANGES, s, 1, 4, 4):

m=s[0:5]

return [m, m[1:]]

global _G

pos = 0

m = False

hasComma = False

sl = len(s);

if (sl > 2) and ('{' == s[pos]):

m = ['', '', None]

pos+=1

l=match_chars(_G.SPACES, s, pos)

if l: pos += l

l=match_char_range(_G.DIGITS_RANGE, s, pos)

if l:

m[1] = s[pos:pos+l]

pos += l

else:

return False

l=match_chars(_G.SPACES, s, pos)

if l: pos += l

if (pos<sl) and (',' == s[pos]):

pos += 1

hasComma = True

l=match_chars(_G.SPACES, s, pos)

if l: pos += l

l=match_char_range(_G.DIGITS_RANGE, s, pos)

if l:

m[2] = s[pos:pos+l]

pos += l

l=match_chars(_G.SPACES, s, pos)

if l: pos += l

if (pos<sl) and ('}' == s[pos]):

pos+=1

m[0] = s[0:pos]

if not hasComma: m[2] = m[1]

return m

else:

return False

global _G

sequence = []

allchars = []

chars = []

flags = {}

isRange = False

escaped = False

ch = ''

if '^' == re_obj.re[re_obj.pos]:

flags[ "NegativeMatch" ] = 1

re_obj.pos+=1

lre = re_obj.len

while re_obj.pos < lre:

isUnicode = False

isHex = False

prevch = ch

ch = re_obj.re[re_obj.pos]

re_obj.pos+=1

escaped = True if ESC == ch else False

if escaped:

ch = re_obj.re[re_obj.pos]

re_obj.pos+=1

if escaped:

# unicode character

if 'u' == ch:

m = match_unicode( re_obj.re[re_obj.pos-1:] )

re_obj.pos += len(m[0])-1

ch = Node(T_UNICODECHAR, m[0], {"Char": chr(int(m[1], 16)), "Code": m[1]})

isUnicode = True

isHex = False

# hex character

elif 'x' == ch:

m = match_hex( re_obj.re[re_obj.pos-1:] )

re_obj.pos += len(m[0])-1

ch = Node(T_HEXCHAR, m[0], {"Char": chr(int(m[1], 16)), "Code": m[1]})

isUnicode = True

isHex = True

if isRange:

if len(chars):

allchars = allchars + chars

chars = []

range[1] = ch

isRange = False

sequence.append( Node(T_CHARRANGE, range) )

else:

if escaped:

if isUnicode:

if len(chars):

allchars = allchars + chars

chars = []

sequence.append( ch )

elif (ch in _G.specialCharsEscaped) and ('/' != ch):

if len(chars):

allchars = allchars + chars

chars = []

flag = {}

flag[ _G.specialCharsEscaped[ch] ] = 1

sequence.append( Node(T_SPECIAL, ch, flag) )

else:

chars.append( ch )

else:

# end of char group

if ']' == ch:

if len(chars):

allchars = allchars + chars

chars = []

# map all chars into one node

if len(allchars): sequence.append( Node(T_CHARS, allchars) )

return Node(T_CHARGROUP, sequence, flags)

elif '-' == ch:

range = [prevch, '']

if isinstance(prevch,Node): sequence.pop()

else: chars.pop()

isRange = True

else:

chars.append( ch )

if len(chars):

allchars = allchars + chars

chars = []

# map all chars into one node

if len(allchars): sequence.append( Node(T_CHARS, allchars) )

global _G

word = ''

wordlen = 0

alternation = []

sequence = []

flags = {}