|
|
var $module=(function($B){
|
|
|
|
|
|
var _b_ = $B.builtins
|
|
|
var $s=[]
|
|
|
for(var $b in _b_) $s.push('var ' + $b +'=_b_["'+$b+'"]')
|
|
|
eval($s.join(';'))
|
|
|
|
|
|
var JSObject = $B.JSObject
|
|
|
|
|
|
var obj = {__class__:$module,
|
|
|
__str__: function(){return "<module 're'>"}
|
|
|
}
|
|
|
obj.A = obj.ASCII = 256
|
|
|
obj.I = obj.IGNORECASE = 2 // 'i'
|
|
|
obj.L = obj.LOCALE = 4
|
|
|
obj.M = obj.MULTILINE = 8 // 'm'
|
|
|
obj.S = obj.DOTALL = 16
|
|
|
obj.U = obj.UNICODE = 32
|
|
|
obj.X = obj.VERBOSE = 64
|
|
|
obj._is_valid = function(pattern) {
|
|
|
if ($B.$options.re=='pyre') return false //force use of python's re module
|
|
|
if ($B.$options.re=='jsre') return true //force use of brythons re module
|
|
|
// FIXME: Improve
|
|
|
|
|
|
if (!isinstance(pattern, str)) {
|
|
|
// this is probably a SRE_PATTERN, so return false, and let
|
|
|
// python's re module handle this.
|
|
|
return false
|
|
|
}
|
|
|
var is_valid = false;
|
|
|
try {
|
|
|
new RegExp(pattern);
|
|
|
is_valid = true;
|
|
|
}
|
|
|
catch(e) {}
|
|
|
if (!is_valid) return false //if js won't parse the pattern return false
|
|
|
|
|
|
// using reference http://www.regular-expressions.info/
|
|
|
// to compare python re and javascript regex libraries
|
|
|
|
|
|
// look for things javascript does not support
|
|
|
// check for name capturing group
|
|
|
var mylist=['?P=', '?P<', '(?#', '(?<=', '(?<!', '(?(']
|
|
|
for(var i=0, _len_i = mylist.length; i < _len_i; i++) {
|
|
|
if (pattern.indexOf(mylist[i]) > -1) return false
|
|
|
}
|
|
|
|
|
|
var re_list=['\{,\d+\}']
|
|
|
for(var i=0, _len_i = re_list.length; i < _len_i; i++) {
|
|
|
var _re=new RegExp(re_list[i])
|
|
|
if (_re.test(pattern)) return false
|
|
|
}
|
|
|
|
|
|
// it looks like the pattern has passed all our tests so lets assume
|
|
|
// javascript can handle this pattern.
|
|
|
return true
|
|
|
}
|
|
|
var $SRE_PatternDict = {
|
|
|
__class__:$B.$type,
|
|
|
__name__:'SRE_Pattern'
|
|
|
}
|
|
|
$SRE_PatternDict.__mro__ = [$SRE_PatternDict,object.$dict]
|
|
|
$SRE_PatternDict.findall = function(self,string){
|
|
|
return obj.findall(self.pattern,string,self.flags)
|
|
|
}
|
|
|
$SRE_PatternDict.finditer = function(self,string){
|
|
|
return obj.finditer(self.pattern,string,self.flags)
|
|
|
}
|
|
|
$SRE_PatternDict.match = function(self,string){
|
|
|
return obj.match(self.pattern,string,self.flags)
|
|
|
}
|
|
|
$SRE_PatternDict.search = function(self,string){
|
|
|
return obj.search(self.pattern,string,self.flags)
|
|
|
}
|
|
|
function normflags(flags) {
|
|
|
return ((flags & obj.I)? 'i' : '') + ((flags & obj.M)? 'm' : '');
|
|
|
}
|
|
|
obj.compile = function(pattern,flags){
|
|
|
return {
|
|
|
__class__:$SRE_PatternDict,
|
|
|
pattern:pattern,
|
|
|
flags:normflags(flags)
|
|
|
}
|
|
|
}
|
|
|
obj.escape = function(string){
|
|
|
// Escape all the characters in pattern except ASCII letters, numbers
|
|
|
// and '_'. This is useful if you want to match an arbitrary literal
|
|
|
// string that may have regular expression metacharacters in it.
|
|
|
var res = ''
|
|
|
var ok = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_'
|
|
|
for(var i=0, _len_i = string.length; i < _len_i;i++){
|
|
|
if(ok.search(string.charAt(i))>-1){res += string.charAt(i)}
|
|
|
}
|
|
|
return res
|
|
|
}
|
|
|
obj.findall = function(pattern,string,flags){
|
|
|
var $ns=$B.args('re.findall',2,
|
|
|
{pattern:null, string:null}, ['pattern', 'string'],
|
|
|
arguments,{},'args','kw') ,
|
|
|
args = $ns['args'] ,
|
|
|
_flags = 0;
|
|
|
if(args.length>0){var flags=args[0]}
|
|
|
else{var _flags = getattr($ns['kw'], 'get')('flags',0)}
|
|
|
|
|
|
var flags = normflags();
|
|
|
flags += 'gm'
|
|
|
var jsp = new RegExp(pattern,flags) ,
|
|
|
jsmatch = string.match(jsp);
|
|
|
if(jsmatch===null){return []}
|
|
|
return jsmatch
|
|
|
}
|
|
|
obj.finditer = function(pattern,string,flags){
|
|
|
var $ns=$B.args('re.finditer',2,
|
|
|
{pattern:null, sring:null}, ['pattern','string'],
|
|
|
arguments,{},'args','kw'),
|
|
|
args = $ns['args'],
|
|
|
_flags = 0;
|
|
|
if(args.length>0){var flags=args[0]}
|
|
|
else{var _flags = getattr($ns['kw'], 'get')('flags',0)}
|
|
|
|
|
|
var flags = normflags();
|
|
|
flags += 'gm'
|
|
|
var jsp = new RegExp(pattern,flags),
|
|
|
jsmatch = string.match(jsp);
|
|
|
if(jsmatch===null){return []}
|
|
|
|
|
|
var _list=[]
|
|
|
for (var j=0, _len_j = jsmatch.length; j < _len_j; j++) {
|
|
|
var mo = {}
|
|
|
mo._match=jsmatch[j]
|
|
|
mo.group = function(){
|
|
|
var res = []
|
|
|
for(var i=0, _len_i = arguments.length; i < _len_i;i++){
|
|
|
if(jsmatch[arguments[i]]===undefined){res.push(None)}
|
|
|
else{res.push(jsmatch[arguments[i]])}
|
|
|
}
|
|
|
if(arguments.length===1){return res[0]}
|
|
|
return tuple(res)
|
|
|
}
|
|
|
mo.groups = function(_default){
|
|
|
if(_default===undefined){_default=None}
|
|
|
var res = []
|
|
|
for(var i=1, _len_i = jsmatch.length; i < _len_i;i++){
|
|
|
if(jsmatch[i]===undefined){res.push(_default)}
|
|
|
else{res.push(jsmatch[i])}
|
|
|
}
|
|
|
return tuple(res)
|
|
|
}
|
|
|
mo.start = function(){return mo._match.index}
|
|
|
mo.end = function(){return mo._match.length-mo._match.index}
|
|
|
mo.string = string
|
|
|
_list.push(JSObject(mo))
|
|
|
}
|
|
|
return _list
|
|
|
}
|
|
|
obj.search = function(pattern,string){
|
|
|
var $ns=$B.args('re.search', 2,
|
|
|
{pattern:null, string:null},['pattern','string'],
|
|
|
arguments,{},'args','kw')
|
|
|
var args = $ns['args']
|
|
|
if(args.length>0){var flags=args[0]}
|
|
|
else{var flags = getattr($ns['kw'],'get')('flags','')}
|
|
|
flags = normflags(flags);
|
|
|
var jsp = new RegExp(pattern,flags)
|
|
|
var jsmatch = string.match(jsp)
|
|
|
if(jsmatch===null){return None}
|
|
|
var mo = new Object()
|
|
|
mo.group = function(){
|
|
|
var res = []
|
|
|
for(var i=0, _len_i = arguments.length; i < _len_i;i++){
|
|
|
if(jsmatch[arguments[i]]===undefined){res.push(None)}
|
|
|
else{res.push(jsmatch[arguments[i]])}
|
|
|
}
|
|
|
if(arguments.length===1){return res[0]}
|
|
|
return tuple(res)
|
|
|
}
|
|
|
mo.groups = function(_default){
|
|
|
if(_default===undefined){_default=None}
|
|
|
var res = []
|
|
|
for(var i=1, _len_i = jsmatch.length; i < _len_i;i++){
|
|
|
if(jsmatch[i]===undefined){res.push(_default)}
|
|
|
else{res.push(jsmatch[i])}
|
|
|
}
|
|
|
return tuple(res)
|
|
|
}
|
|
|
mo.start = function(){return jsmatch.index}
|
|
|
mo.end = function(){return jsmatch.length-jsmatch.index}
|
|
|
mo.string = string
|
|
|
return JSObject(mo)
|
|
|
}
|
|
|
obj.sub = function(pattern,repl,string){
|
|
|
var $ns=$B.args('re.search', 3,
|
|
|
{pattern:null, repl:null, string:null},
|
|
|
['pattern','repl','string'],
|
|
|
arguments,{},'args','kw')
|
|
|
for($var in $ns){eval("var "+$var+"=$ns[$var]")}
|
|
|
var args = $ns['args']
|
|
|
var count = _b_.dict.$dict.get($ns['kw'],'count',0)
|
|
|
var flags = _b_.dict.$dict.get($ns['kw'],'flags','')
|
|
|
if(args.length>0){var count=args[0]}
|
|
|
if(args.length>1){var flags=args[1]}
|
|
|
flags = normflags(flags);
|
|
|
if(typeof repl==="string"){
|
|
|
// backreferences are \1, \2... in Python but $1,$2... in Javascript
|
|
|
repl = repl.replace(/\\(\d+)/g,'$$$1')
|
|
|
}else if(typeof repl==="function"){
|
|
|
// the argument passed to the Python function is the match object
|
|
|
// the arguments passed to the Javascript function are :
|
|
|
// - the matched substring
|
|
|
// - the matched groups
|
|
|
// - the offset of the matched substring inside the string
|
|
|
// - the string being examined
|
|
|
var $repl1 = function(){
|
|
|
var mo = Object()
|
|
|
mo.string = arguments[arguments.length-1]
|
|
|
var start = arguments[arguments.length-2]
|
|
|
var end = start + arguments[0].length
|
|
|
mo.start = function(){return start}
|
|
|
mo.end = function(){return end}
|
|
|
groups = []
|
|
|
for(var i=1, _len_i = arguments.length-2; i < _len_i;i++){groups.push(arguments[i])}
|
|
|
mo.groups = function(_default){
|
|
|
if(_default===undefined){_default=None}
|
|
|
var res = []
|
|
|
for(var i=0, _len_i = groups.length; i < _len_i;i++){
|
|
|
if(groups[i]===undefined){res.push(_default)}
|
|
|
else{res.push(groups[i])}
|
|
|
}
|
|
|
return res
|
|
|
}
|
|
|
return repl(JSObject(mo))
|
|
|
}
|
|
|
}
|
|
|
if(count==0){flags+='g'}
|
|
|
var jsp = new RegExp(pattern,flags)
|
|
|
if(typeof repl==='function'){return string.replace(jsp,$repl1)}
|
|
|
else{return string.replace(jsp,repl)}
|
|
|
}
|
|
|
obj.match = (function(search_func){
|
|
|
return function(){
|
|
|
// match is like search but pattern must start with ^
|
|
|
var pattern = arguments[0]
|
|
|
if(pattern.charAt(0)!=='^'){pattern = '^'+pattern}
|
|
|
var args = [pattern]
|
|
|
for(var i=1, _len_i = arguments.length; i < _len_i;i++){args.push(arguments[i])}
|
|
|
return search_func.apply(null,args)
|
|
|
}
|
|
|
})(obj.search)
|
|
|
|
|
|
return obj
|
|
|
}
|
|
|
)(__BRYTHON__)
|
|
|
|
