Ticket #174: regexp-lit-ops3.patch

Source/Expr.cobra

@@ -2659 +2659 @@
         base._bindImp
         _type = .compiler.nilType
 
+class RegexpLit
+    is partial
+    inherits AtomicLiteral
+    """
+    A Regular Expression Literal.
 
+    Form is similar to that of a (raw) string; single or double quote delimited but with a 're' prefix.
+    It may be either a just a pattern (delimited or not)    re'<Ptn>' or re'/<Ptn>/' 
+        or a delimited pattern with option flags            re'/<Ptn>/<flags>'.
+
+    If flags are desired the pattern must be delimited (with matching /) and any flags follow the trailing /
+
+    Flags can be one or more of:
+        i - Ignorecase =  case-insensitive matching.
+        c - Compile  =  compile the RE. This yields faster execution but increases startup time
+        s - Singleline = Single-line mode. Change so '.' matches every char instead of '[^\n]*' (every character except \n).
+        m - Multiline = Multiline mode. Change so '^' and '$' match start and end of lines instead of start and end of entire string
+        x - ExplicitCaptures - the only valid captures are explicitly named or numbered groups of the form (?<name>�). 
+        W - Ignores unescaped white space in the pattern and enables comments marked with '#'. 
+        
+    e.g
+        re'[A-Za-z_][A-Za-z0-9_]*'
+        re"/c'(?:\\'|\\?[^'])'/"        
+        re'/^\s*@param\s+(.*)$/m'   # multiline
+        re'/args\s+\w+/i'           # Case insensitive
+    """
+
+    var _string as String   # Regexp raw pattern (with no surrounding quotes) with possible delimiters and flags
+    var _pattern as String  # Regexp pattern (no delimiters)
+    var _flags as String = '' 
+
+    const _validFlags = 'icsmxW'
+    
+    cue init(token as IToken)
+        require token.which.startsWith('REGEXP')
+        base.init(token as IToken)
+        _string = token.value to String
+        _pattern=''
+
+    get string from var
+    get pattern from var
+    get flags from var
+    
+    def _bindInt is override
+        if not _type
+            _type = .compiler.regexpType
+        base._bindInt
+
+    def _bindImp is override
+        str = _string
+        if str.startsWith('/')
+            str = str[1:]
+            idx = str.lastIndexOf('/')
+            if idx == -1
+                sugg = 'Did you mean "/[str]/"'
+                .throwError('Regexp Literal has an opening "/" delimiter but no trailing delimiter. [sugg]')
+            p = str[:idx]           # p = str.before('/')
+            flags = str[idx+1:]     # flags = str.after('/')
+        else
+            p = str
+            flags = '' # no flags
+        if not p.length, .throwError('Regexp Literal has no pattern specified.')    
+        _pattern = p
+        for fl in flags
+            if not fl in _validFlags
+                .throwError('Unrecognised Regexp flag "[fl]" in Regexp Literal "[.string]". Flag must be one of the characters "[_validFlags]".')
+        _flags = flags
+        if not _type
+            _type = .compiler.regexpType
+        base._bindImp
+
+    def toCobraSource as String is override
+        return .token.text
+
 class StringLit
     is partial
     inherits AtomicLiteral

Source/BackEndClr/SharpGenerator.cobra

@@ -3832 +3832 @@
         return 'null'
 
 
+class RegexpLit
+    is partial
+
+    var _flagsToOptions = { 
+        c'i' : 'RegexOptions.IgnoreCase',
+        c'c' : 'RegexOptions.Compiled',
+        c's' : 'RegexOptions.Singleline',
+        c'm' : 'RegexOptions.Multiline',
+        c'x' : 'RegexOptions.ExplicitCapture',
+        c'W' : 'RegexOptions.IgnorePatternWhitespace',
+    }
+
+    get asSharp as String is override
+        return Utils.sharpStringLiteralFor(_string)
+        
+    def writeSharpDef(sw as CurlyWriter, parens as bool) is override
+        if parens, sw.write('( ')
+        sw.write('new [_type.sharpRef]( ')
+        sw.write('@"[.pattern]"')
+        
+        if .flags.length
+            assert _flagsToOptions.count == _validFlags.length, 'RegexpLit flagsMap out of sync with list of valid flags'   
+            sb = StringBuilder(',')
+            sep = ''
+            for fl in .flags
+                sb.append('[sep] System.Text.RegularExpressions.[_flagsToOptions[fl]] ')
+                sep = '|' 
+            sw.write(sb.toString)
+        sw.write(')')
+        if parens, sw.write(' )')
+        
 class StringLit
     is partial
 
     get asSharp as String is override
         return Utils.sharpStringLiteralFor(_string)
 
-
 class StringSubstLit
     is partial
 
@@ -4467 +4497 @@
             itemIndex += 1
         sw.write(')')
 
+class RegexpExpr
+    is partial
+    
+    def writeSharpDef(sw as CurlyWriter, parens as bool) is override
+        if parens, sw.write('(')
+        _writeSharpDef(sw)
+        if parens, sw.write(')')
 
+    def _writeSharpDef(sw as CurlyWriter) is override
+        left = _left
+        right = _right
+        op = _op
+        
+        if left.type.isDynamic or right.type.isDynamic
+            call = 'CobraLangInternal.CobraImp.DynamicRegexp'
+            branch op
+                on 'TILDE',         call += 'Match'
+                on 'RE_HASMATCH',   call += 'HasMatch'
+                on 'RE_MATCHES',    call += 'Matches'
+                on 'RE_SPLITS',     call += 'Splits'
+                else
+                    throw FallThroughException('Unknown regexp op [op]')
+            sw.write(call+ '(')
+            left.writeSharpDef(sw, false)
+            sw.write(',')
+            right.writeSharpDef(sw, false)
+            sw.write(')')
+            return
+                
+        assert op in ['TILDE', 'RE_MATCHES', 'RE_HASMATCH', 'RE_SPLITS'] # TILDE_COLON']
+        branch op
+            on 'TILDE',         call = 'CobraLangInternal.CobraImp.RegexpMatch('    #'.Match('
+            on 'RE_HASMATCH',   call = '.IsMatch('
+            on 'RE_MATCHES',    call = '.Matches('
+            on 'RE_SPLITS',     call = 'CobraLangInternal.CobraImp.RegexpSplits('   #'.Split('
+            else
+                throw FallThroughException('Unknown regexp op [op]')
+        if op == 'TILDE' or op == 'RE_SPLITS' 
+            sw.write(call)
+            left.writeSharpDef(sw)
+            sw.write(', ')
+            right.writeSharpDef(sw, false)
+            sw.write(')')
+        else
+            left.writeSharpDef(sw)
+            sw.write(call)
+            right.writeSharpDef(sw, false)
+            sw.write(')')
+    
+    
 class DotExpr
     is partial
 

Source/CobraTokenizer.cobra

@@ -131 +131 @@
             r"SHARP_SINGLE          sharp'(?:\\.?|[^'\n])*'",
             r'SHARP_DOUBLE          sharp"(?:\\.?|[^"\n])*"',
 
+            # regexp Literal strings
+            r"REGEXP_SINGLE         re'(?:\\.?|[^'\n])*'",
+            r'REGEXP_DOUBLE         re"(?:\\.?|[^"\n])*"',
+
             # raw strings
             r"STRING_RAW_SINGLE     r'(?:\\.?|[^'\n])*'",
             r'STRING_RAW_DOUBLE     r"(?:\\.?|[^"\n])*"',
@@ -195 +199 @@
             r'AMPERSAND         \&',
             r'VERTICAL_BAR      \|',
             r'CARET             \^',
-            r'TILDE             \~',
+            r'TILDE             \~',  # RE_MATCH
 
             r'EQ                ==',
             r'NE                <>',
@@ -220 +224 @@
 
             r'QUESTION_EQUALS   \?=',
             r'BANG_EQUALS       \!=',
+            r'RE_HASMATCH       \~=',
+            r'RE_SPLITS         \~\|',
         ]
 
     get keywords as IList<of String> is override
@@ -811 +817 @@
         return tok
 
     ##
+    ## Regexp Literal String 
+    ##  re'/<rePattern>/<flags>' or re'<rePattern>'  or
+    ##  re"/<rePattern>/<flags>" or re"<rePattern>"
+    ##      Currently only single line 
+    ##      TODO: support multiline for IgnorePatternWhitespace  when strings do.
+    
+    def onREGEXP_SINGLE(tok as IToken) as IToken
+        require tok.text.startsWith('re')
+        #tok.value =.tokValueForString(tok.text.substring(2))
+        tok.value = tok.text[3:-1]   # contents between re' and '
+        tok.which = 'REGEXP_LIT'
+        return tok
+
+    def onREGEXP_DOUBLE(tok as IToken) as IToken
+        require tok.text.startsWith('re')
+        #tok.value =.tokValueForString(tok.text.substring(2))
+        tok.value = tok.text[3:-1]  
+        tok.which = 'REGEXP_LIT'
+        return tok
+
+    ##
     ## Simple string literals
     ##
 

Source/Compiler.cobra

@@ -1178 +1178 @@
     def stringType as Class
         return _libraryClass('System.String')
 
+    def regexpType as Class
+        return _libraryClass('System.Text.RegularExpressions.Regex')
+
+    def regexpMatchType as Class
+        return _libraryClass('System.Text.RegularExpressions.Match')
+
+    def regexpManyMatchType as Class
+        return _libraryClass('System.Text.RegularExpressions.MatchCollection')
+
     def exceptionType as Class
         return _libraryClass('System.Exception')
 

Source/Cobra.Lang/Native.cs

@@ -853 +853 @@
     }
 
 
+        // Regex wrappers non dynamic
+        // Single match: Null on failure, Match on success
+        static public System.Text.RegularExpressions.Match RegexpMatch(System.Text.RegularExpressions.Regex re, string str)
+        {
+            System.Text.RegularExpressions.Match m = re.Match(str);
+            return m.Success ? m : null;
+        }
+
+        static public List<String> RegexpSplits(System.Text.RegularExpressions.Regex re, string str)
+        {
+            String[] sa = re.Split(str);
+            return new List<String>(sa);
+        }
+        
     // Dynamic Binding
 
     static private readonly BindingFlags BaseDynamicFlags = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy; 
@@ -1202 +1216 @@
         return a + b;
     }
 
+
+    // Handling for dynamic operands with regexp operator
+    static public System.Text.RegularExpressions.Match DynamicRegexpMatch(Object a, Object b) {
+        DynamicRegexp_Chk(a,b);
+                System.Text.RegularExpressions.Regex re = (System.Text.RegularExpressions.Regex)a;
+                string str = (string)b;
+                return RegexpMatch(re, str);
+    }
+    static public bool DynamicRegexpHasMatch(Object a, Object b) {
+        DynamicRegexp_Chk(a,b);
+                System.Text.RegularExpressions.Regex re = (System.Text.RegularExpressions.Regex)a;
+                string str = (string)b;
+                return re.IsMatch(str);
+        }
+    static public System.Text.RegularExpressions.MatchCollection DynamicRegexpMatches(Object a, Object b) {
+        DynamicRegexp_Chk(a,b);
+                System.Text.RegularExpressions.Regex re = (System.Text.RegularExpressions.Regex)a;
+                string str = (string)b;
+                return re.Matches(str);
+        }
+    static public List<String> DynamicRegexpSplits(Object a, Object b) {
+        DynamicRegexp_Chk(a,b);
+                System.Text.RegularExpressions.Regex re = (System.Text.RegularExpressions.Regex)a;
+                string str = (string)b;
+                return RegexpSplits(re, str);
+                //return new List<String(re.Split(str));
+        }
+    static void DynamicRegexp_Chk(Object a, Object b) {
+        if (a == null) throw new NullReferenceException("First operand nil, expecting a Regexp");
+        if (b == null) throw new NullReferenceException("Second operand nil, expecting a String");
+        //if (!(a.GetType() is System.Text.RegularExpressions.Regex)) {
+                if (!(a.GetType().Name == "Regex")) {       
+                        throw new ArgumentException("First operand in dynamic regexp match expression must be a Regex not "+ a.GetType().Name);
+                }
+        //if (!(b.GetType() is string) ) {
+                if (!(b.GetType().Name == "String") ) {
+            throw new ArgumentException("Second operand in dynamic regexp match expression must be a String not "+ b.GetType().Name);
+                }
+        }
+
     static public string RunAndCaptureAllOutput(object process) {
         // CC: change to extension method on Process class
         System.Diagnostics.Process proc = (System.Diagnostics.Process)process;

Source/BinaryOpExpr.cobra

@@ -13 +13 @@
         BinaryMathExpr
     BinaryBoolExpr
     CompareExpr
+    RegexpExpr
     DotExpr
     InExpr
     InheritsExpr
@@ -70 +71 @@
                     return BinaryBitwiseExpr(opToken, op, left, right)
                 on 'AMPERSAND_EQUALS' or 'VERTICAL_BAR_EQUALS' or 'CARET_EQUALS' or 'DOUBLE_LT_EQUALS' or 'DOUBLE_GT_EQUALS'
                     return AugAssignBitwiseExpr(opToken, op, left, right)
+                on 'TILDE' or 'RE_HASMATCH' or 'RE_SPLITS' # TILDE_COLON
+                    return RegexpExpr(opToken, op, left, right)
                 else
                     throw FallThroughException([opToken, op, left, right])
 
@@ -601 +604 @@
                 msg += ' Maybe you should try "inherits" instead of "is".'
             .throwError(msg)
 
+class RegexpExpr
+    is partial
+    inherits BinaryOpExpr
 
+    # TODO: TILDE_COLON = substitute
+
+    cue init(opToken as IToken, op as String, left as Expr, right as Expr)
+        base.init(opToken, op, left, right)
+
+    def _bindImp
+        base._bindImp
+        if _left.type is nil or _right.type is nil
+            assert .hasError
+            return
+        leftType = _left.type to !
+        rightType = _right.type to !
+        # expr is 're isMatch str' or 're match str' or 're (all)matches str' which works for me - re always lhs
+        # but 're split str' seems wrong way round ( 'str split(by) re' seems more natural)
+        # so its 're splits str' - re on lhs 
+        if not (leftType inherits NilableType and leftType.isDynamic) and not leftType.isDynamicOrPassThrough and not leftType.isDescendantOf(.compiler.regexpType)
+            .throwError('The leftside of regexp op "[.token.text]" must be a RegularExpression type not a [leftType.name]')
+        if not (rightType inherits NilableType and rightType.isDynamic) and not rightType.isDynamicOrPassThrough and not rightType is .compiler.stringType
+            .throwError('The rightside of regexp op "[.token.text]" must be a String type not a [rightType.name]')
+            
+        assert .op in ['TILDE', 'RE_HASMATCH', 'RE_SPLITS']  # RE_SUBST (~:)
+        if .op == 'TILDE'   # regexp match
+            _type = .compiler.nilableType(.compiler.regexpMatchType)
+            # overload for 'm in re ~ str'
+            #print .superNode
+            if .superNode inherits ForEnumerableStmt 
+                _op = 'RE_MATCHES'
+                _type = .compiler.regexpManyMatchType
+        else if .op == 'RE_HASMATCH'    #   '~='
+            _type = .compiler.boolType
+        else if .op == 'RE_SPLITS'  #   '~|'
+            _type = .compiler.listOfType.constructedTypeFor([.compiler.stringType to IType]) # List<of String>
+            #_type = .compiler.arrayType(compiler.stringType) # Array of String
+            
+                
 interface IDotRightExpr
     inherits IExpr
     """

Source/Node.cobra

@@ -1212 +1212 @@
     def objectClass as Class
     def setOfType as Class
     def stringType as Class
+    def regexpType as Class
+    def regexpMatchType as Class
+    def regexpManyMatchType as Class
 
 
     ## Other

Source/CobraParser.cobra

@@ -2668 +2668 @@
             'INHERITS':         40,
             'IMPLEMENTS':       40,
 
+            'TILDE':            37,  # RE_MATCH
+            'RE_HASMATCH':      37,  # TILDE_EQUALS (~=) is REGEXP_HASMATCH test not augmented assignment 
+            'RE_SPLITS':        37,  # TILDE_BAR ~|
+            
             'IN':               35,
             'NOTIN':            35,
 
@@ -2691 +2695 @@
             'CARET_EQUALS':         20,
             'DOUBLE_LT_EQUALS':     20,
             'DOUBLE_GT_EQUALS':     20,
+
         }
 
         get binaryOpPrec from var
@@ -2720 +2725 @@
                 return expr
             finally
                 _inExpression -= 1
-
     def expression(precedence as int) as Expr
         return .expression(precedence, nil)
 
@@ -2878 +2882 @@
                 return FractionalLit(.grab)
             on 'FLOAT_LIT'
                 return FloatLit(.grab)
+            on 'REGEXP_LIT'
+                return RegexpLit(.grab)
             on 'LBRACKET'
                 return .literalList
             on 'ARRAY_OPEN'

Tests/320-misc-two/410-regexp/250-regexp-matches-expr.cobra

@@ +1 @@
+class REMatches
+
+    def main is shared
+        str = '@param farethee well\n @param fare thee well\n@param fare tw my darling maid'
+        re = re'/^\s*@param\s+(.*)$/m'
+        reX = re'/^\s*quack quack Quaack\s+(.*)$/m'
+        
+        for m in re ~ str
+            assert m.success
+            assert m.groups[0].value.trim.startsWith('@param')
+        
+        c=0
+        for m in reX ~ str
+            c += 1
+        assert c == 0
+            
+        c = 0
+        for m in re'\s*well' ~ str
+            c += 1
+            assert m.value == ' well'
+        assert c == 2

Tests/320-misc-two/410-regexp/210-regexp-match-expr.cobra

@@ +1 @@
+use System.Text.RegularExpressions
+
+class ReMatch
+
+    def main is shared
+        str = '@param farethee well\n @param fare thee well\n@param ftw my darling maid'
+        
+        re0 = Regex(r'^\s*@param\s+(.*)$', RegexOptions.Multiline)
+        m0 = re0.match(str)
+        re = re'/^\s*@param\s+(.*)$/m'
+        reX = re'/^\s*quack quack Quaack\s+(.*)$/m'
+
+        assert re ~= str
+        m = re ~ str
+        assert m  
+        assert 'Match' in m.typeOf.toString
+        assert m.success 
+        .matchMatches(m, m0)
+
+        if re ~= str, assert true
+        else, assert false, 're ~= str FAIL'
+        if re ~ str, assert true
+        else, assert false, 're ~str FAIL'
+        
+        # Non matching
+        assert not reX ~= str 
+        assert not reX ~ str 
+        m00 = reX ~ str     # failure to match with ~ returns nil
+        assert not m00 
+        assert m00 == nil
+
+        if not reX ~= str, assert true
+        else, assert false, 'not reX ~= str FAIL'
+            
+        if not reX ~ str, assert true
+        else, assert false, 'not reX ~ str FAIL'
+        
+            
+        reA = re'/^\s*@param\s+(.*)\n/' # non Multiline, match EOL
+        assert reA ~= str
+        
+        reB = re'^\s*@param\s+(.*)'     # No flags at all
+        assert reB ~= str
+
+        assert not re'^\s*@PARAM\s+(.*)' ~= str     # case sensitive
+        assert  re'/^\s*@PARAM\s+(.*)/i' ~= str     # case insensitive
+        
+        
+        re2 = Regex(r'^\s*@param\s+(.*)$', RegexOptions.Singleline)
+        assert re2 ~= str
+        assert re'/^\s*@param\s+(.*)$/s' ~= str
+        reC = re'/^\s*@param\s+(.*)$/s'
+        .matchMatches(re2 ~ str, reC ~ str)
+    
+        
+    def matchMatches(m as Match?, m0 as Match?) is shared
+        # assert m == m0 fails as does m.groups[0] == m0.groups[0]... 
+        # but ..
+        assert m
+        assert m0
+        assert m.success  == m0.success
+        assert m.value == m0.value 
+        assert m.groups[0].toString == m0.groups[0].toString
+        assert m.groups[0].captures[0].toString == m0.groups[0].captures[0].toString
+        assert m.groups[1].toString == m0.groups[1].toString
+        

Tests/320-misc-two/410-regexp/110-regexp-lit2.cobra

@@ +1 @@
+class RegexpLit
+    def main is shared
+        str = 'Diddly pom, diddley pam, diddley pumlee'
+        
+        reC = re'/p.m/c'    # compiled
+        assert reC.isMatch(str)
+    
+        m = reC.match(str)
+        assert m.success
+        assert m.value == 'pom'
+    
+        m = m.nextMatch to !
+        assert m.success
+        assert m.success
+        assert m.value == 'pam'
+        
+        m = m.nextMatch to !
+        assert m.success
+        assert m.success
+        assert m.value == 'pum'
+        
+        m = m.nextMatch to !
+        assert not m.success
+        assert not m.value.length
+        
+    
+        rex = re'/[Dd]\w+\W(p.m)/'  
+        m = rex.match(str)
+        assert m.success
+        assert m.value == 'Diddly pom'
+        assert m.groups[1].captures.count == 1
+        assert m.groups[1].captures[0].value == 'pom'
+        
+        # Explicit capture flag
+        rex = re'/[Dd]\w+\W(p.m)/x' 
+        m = rex.match(str)
+        assert m.success
+        assert m.value == 'Diddly pom'
+        assert m.groups[1].captures.count == 0
+        
+        rex = re'/[Dd]\w+\W(?<v>p.m)/x' 
+        m = rex.match(str)
+        assert m.success
+        assert m.value == 'Diddly pom'
+        assert m.groups[1].captures.count == 1
+        assert m.groups[1].captures[0].value == 'pom'
+        

Tests/320-misc-two/410-regexp/120-regexp-lit-matches.cobra

@@ +1 @@
+class RegexpLit
+    def main is shared
+        str = 'Ka mate, Ka mate, Ki ora, Ki ora'
+        
+        re = re'/[Kk]. \w/'
+        assert re.isMatch(str)
+    
+        for m in re.matches(str)
+            assert m.value in ['Ka m', 'Ki o']
+        
+        mc = re.matches(str)
+        assert mc.count == 4
+        
+        assert mc[0].value == 'Ka m'
+        assert mc[1].value == 'Ka m'
+        assert mc[2].value == 'Ki o'
+        assert mc[3].value == 'Ki o'
+        

Tests/320-misc-two/410-regexp/200-regexp-match-min.cobra

@@ +1 @@
+# simple test of each of '~=', '~' and 'for m in re ~ str'
+class ReMatch
+
+    def main is shared
+        str = '@param farethee well\n @param fare thee well\n@param fare tw my darling maid'
+        
+        re = re'/^\s*@param\s+(.*)$/m'
+        reX = re'/^no.match.evah$/m'
+        assert  'Regex' in re.typeOf.toString
+
+        # isMatch
+        if re ~= str, assert true 
+        else, assert false, 'str match re - ismatch FAIL'
+        assert re ~= str
+        assert not reX ~= str
+        
+        # Match
+        if re ~ str,  assert true
+        else, assert false, 'str match re - match FAIL'
+        m = re ~ str
+        assert 'Match' in m.typeOf.toString
+        assert m and m.success 
+        #print m
+
+        m = reX ~ str
+        assert not m
+        assert not reX ~ str
+        
+        #Matches/MatchCollection
+        for m in re ~ str
+            assert m.groups[1].value.startsWith('fare')
+        
+        # split
+        reSplit = re'\n?\s?@param '
+        split = reSplit ~| str
+        assert split.count == 4
+        assert split[0] == ''
+        for i in 1 : split.count
+            assert split[i].startsWith('fare')

Tests/320-misc-two/410-regexp/300-regexp-splits.cobra

@@ +1 @@
+# test regexp splits operator
+class RegexpSplits
+    def main
+        re = re'-'
+        str = 'plum|pear'
+        split = re.split(str).toList
+        assert split.count == 1
+        assert split[0] == str
+        
+        split = re ~| str
+        assert split.count == 1
+        assert split[0] == str
+        
+        str = 'plum--pear'
+        split = re.split(str).toList
+        .validate(split, ['plum', '', 'pear'])
+        split = re ~| str
+        .validate(split, ['plum', '', 'pear'])
+        
+        re2 = re'(-)'   
+        str = 'plum-pear'
+        #split = re2.split(str).toList
+        split = re2 ~| str
+        .validate(split, ['plum', '-', 'pear'])
+            
+        str = r'07/14/2007'
+        re3 = re'(-)|(/)'
+        #split = re3.split(str).toList
+        split = re3 ~| str
+        #print split
+        .validate(split, ['07', '/', '14', '/', '2007'])
+    
+        str = "10 blah 20 30 nonsense 40 50"
+        re4 = re'[^\d.]+'
+        #split = re4.split(str).toList
+        split = re4 ~| str
+        .validate(split, [ '10', '20', '30', '40', '50' ])
+        str = "10 blah 20 30 nonsense 40.5 50"      
+        #split = re4.split(str).toList
+        split = re4 ~| str
+        .validate(split, [ '10', '20', '30', '40.5', '50'])
+
+        str = '001ASD003DFG012SASAS210ASSA1000XXX0'
+        re5 = re'([a-zA-Z]+)'
+        #split = re5.split(str).toList
+        split = re5 ~| str
+        .validate(split, ['001', 'ASD', '003', 'DFG', '012', 'SASAS', '210', 'ASSA', '1000', 'XXX', '0' ])
+        
+    def validate(obtained as List<of String>, expected  as List<of String>)
+        assert obtained.count == expected.count
+        for i, match in obtained.numbered       
+            assert match == expected[i]
+            

Tests/320-misc-two/410-regexp/292-regexp-match-dynamic-err.cobra

@@ +1 @@
+class REMatchDynamicErr
+    def main is shared
+        str = '@param any old iron\n @param Any old eyeron\n@param any auld iron at all'
+        re = re'/^\s*@param\s+(.*)$/m'
+        reX = re'/^\s*quack quack Quaack\s+(.*)$/m'
+    
+        # re match ops as dynamic
+        dstr = str to dynamic
+        dre = re to dynamic
+        dreX = reX to dynamic
+        try 
+            assert dstr ~= dre 
+        catch exc as System.ArgumentException
+            #print exc.message
+            assert 'First operand' in exc.message
+            assert 'must be a Regex' in exc.message
+            
+        try 
+            assert dre ~= dreX 
+        catch exc as System.ArgumentException
+            assert 'Second operand' in exc.message
+            assert 'must be a String' in exc.message
+        
+        try 
+            assert dstr ~ dre 
+        catch exc as System.ArgumentException
+            #print exc.message
+            assert 'First operand' in exc.message
+            assert 'must be a Regex' in exc.message
+
+        try 
+            assert dreX ~ dre 
+        catch exc as System.ArgumentException
+            assert 'Second operand' in exc.message
+            assert 'must be a String' in exc.message
+        
+        s1 as dynamic = 'hello' # perhaps forgot re prefix
+        s2 as dynamic = 'othello'
+
+        try 
+            assert s1 ~= s2
+        catch exc as System.ArgumentException
+            #print exc.message
+            assert 'First operand' in exc.message
+            assert 'must be a Regex' in exc.message
+        
+        nd as dynamic? = nil
+        try 
+            assert nd ~ 'hello nil'
+        catch nExc as NullReferenceException
+            assert 'First operand nil' in nExc.message
+            assert 'expecting a Regexp' in nExc.message
+        
+        try 
+            assert dre ~=  nd
+        catch nExc as NullReferenceException
+            assert 'Second operand nil' in nExc.message
+            assert 'expecting a String' in nExc.message
+
+        rs1 as dynamic = re'hello'
+        assert rs1 ~= s2
+        assert rs1 ~ s2
+            

Tests/320-misc-two/410-regexp/165-regexp-lit-delim-err.cobra

@@ +1 @@
+class RegexpLit
+    def main is shared
+    
+        re = re'/f.oo'  # .error. no trailing delimiter 
+        re1 = re'/'     # .error. no trailing delimiter
+        re1 = re'/f.o./'
+        CobraCore.noOp(re,re1)

Tests/320-misc-two/410-regexp/240-regexp-match-dynamic.cobra

@@ +1 @@
+class REMatchDy
+    def main is shared
+        str = '@param Quack\n @param quack well\n@param quack quack quaaaack'
+        
+        re as dynamic = re'/^\s*@param\s+(.*)$/m'
+        reX as dynamic = re'/^\s*quack quack Quaack\s+(.*)$/m'
+
+        assert re ~= str # IsMatch
+        m = re ~ str
+        assert m  
+        assert 'Match' in m.typeOf.toString
+        assert m.success 
+        assert m.value == '@param Quack'
+        assert m.groups[1].captures[0].toString == 'Quack'
+        
+        m = m.nextMatch to !
+        assert m.success
+        assert m.value.trim == '@param quack well'
+        assert m.groups[1].captures[0].toString == 'quack well'
+        m = m.nextMatch to !
+        assert m.success
+        m = m.nextMatch to !
+        assert not m.success
+        
+        if re ~= str, assert true
+        else, assert false, 're ~= str FAIL'
+
+        if re ~ str, assert true
+        else, assert false, 're ~str FAIL'
+        
+        # Non matching
+        assert not reX ~= str 
+        assert not reX ~ str 
+        m00 = reX ~ str     # failure to match with ~ returns nil
+        assert not m00
+
+        if not reX ~= str, assert true
+        else, assert false, 'not reX ~= str FAIL'
+            
+        if not reX ~ str, assert true
+        else, assert false, 'not reX ~ str FAIL'
+        
+        
+        
+        

Tests/320-misc-two/410-regexp/150-regexp-lit-split.cobra

@@ +1 @@
+# Test for Regex split using a RE Literal
+class ReSplit
+
+    def main is shared
+        str ='aaa:-:bbb:+:cc cc:=:'
+        
+        re= re'/:.:/c'   # compiled
+        
+        args = re.split(str)  # returns  String[]
+        assert args.length == 4
+        assert args[0] == 'aaa'
+        assert args[1] == 'bbb'
+        assert args[2] == 'cc cc'
+        assert args[3] == ''
+        
+        argsl = re.split(str).toList 
+        assert argsl.count == 4
+        assert argsl[0] == 'aaa'
+        assert argsl[1] == 'bbb'
+        assert argsl[2] == 'cc cc'
+        assert argsl[3] == ''
+        
+        str1 = 'xxxx-yyyy'
+        args = re.split(str1)
+        assert args.length == 1
+        assert args[0] == str1
+        
+        l = re'[-_+:]'.split(str1).toList
+        assert l.count == 2
+        assert l[0] == 'xxxx'
+        assert l[1] == 'yyyy'
+        

Tests/320-misc-two/410-regexp/100-regexp-lit.cobra

@@ +1 @@
+use System.Text.RegularExpressions
+
+class ReMatch
+
+    def main is shared
+        str = '@param farethee well\n @param fare thee well\n@param ftw my darling maid'
+        
+        re0 = Regex(r'^\s*@param\s+(.*)$', RegexOptions.Multiline)
+        m0 = re0.match(str)
+        #print 'isMatch ?', re0.isMatch(str)
+        #print 'Match ?', m0.success, 'value=', m0.value
+        
+/#      for match in re0.matches(str)
+            # groups[0] is entire match to pattern
+            print '0 {[match.groups[0]]}'
+            print '1 {[match.groups[1].captures[0]]}' 
+            #print match  # == match.value
+            #groups = match.groups 
+            #for group as Group in match.groups
+            #   #print g
+            #   for c in group.captures
+            #       print 'capture=[c]'
+        print   
+#/      
+        re = re'/^\s*@param\s+(.*)$/m'
+        #assert  re.typeOf == System.Text.RegularExpressions.Regex
+        assert  'Regex' in re.typeOf.toString
+
+        assert re.isMatch(str)
+        m = re.match(str)
+        assert m.success 
+        .matchMatches(m, m0)
+
+/#      for match in re.matches(str)
+            # groups[0] is entire match to pattern
+            print '0 {[match.groups[0]]}'
+            print '1 {[match.groups[1].captures[0]]}' 
+            #print match  # == match.value
+            #groups = match.groups 
+            #for group as Group in match.groups
+            #   #print g
+            #   for c in group.captures
+            #       print 'capture=[c]'
+        print   
+#/      
+
+        reA = re'/^\s*@param\s+(.*)\n/' # non Multiline, match EOL
+        assert reA.isMatch(str)
+        
+        reB = re'^\s*@param\s+(.*)'     # No flags at all
+        assert reB.isMatch(str)
+
+        assert not re'^\s*@PARAM\s+(.*)'.isMatch(str)  # case sensitive
+        assert  re'/^\s*@PARAM\s+(.*)/i'.isMatch(str)   # case insensitive
+        
+        
+        re2 = Regex(r'^\s*@param\s+(.*)$', RegexOptions.Singleline)
+        assert re2.isMatch(str)
+        assert re'/^\s*@param\s+(.*)$/s'.isMatch(str)
+        reC = re'/^\s*@param\s+(.*)$/s'
+        .matchMatches(re2.match(str), reC.match(str))
+    
+        
+    def matchMatches(m as Match, m0 as Match) is shared
+        # assert m == m0 fails as does m.groups[0] == m0.groups[0]... 
+        # but ..
+        assert m.success  == m0.success
+        assert m.value == m0.value 
+        assert m.groups[0].toString == m0.groups[0].toString
+        assert m.groups[0].captures[0].toString == m0.groups[0].captures[0].toString
+        assert m.groups[1].toString == m0.groups[1].toString
+        

Tests/320-misc-two/410-regexp/290-regexp-match-err.cobra

@@ +1 @@
+class REMatchErr
+    def main is shared
+    
+        str = '@param any old iron\n @param Any old eyeron\n@param any auld iron at all'
+        re = re'/^\s*@param\s+(.*)$/m'
+        reX = re'/^\s*quack quack Quaack\s+(.*)$/m'
+        
+        assert str ~= re # .error. leftside of regexp op "~=" must be a RegularExpression type  
+        assert re ~= reX # .error. rightside of regexp op "~=" must be a String type  
+        
+        assert str ~ re #.error. leftside of regexp op "~" must be a RegularExpression type  
+        assert reX ~ re #.error. rightside of regexp op "~" must be a String type  
+        
+        assert 'hello' ~= 'othello' # .error. leftside of regexp op "~=" must be a RegularExpression type  

Tests/320-misc-two/410-regexp/220-regexp-match-expr2.cobra

@@ +1 @@
+class RegexpMatchE
+    def main is shared
+        str = 'Diddly pom, diddley pam, diddley pumlee'
+        
+        reC = re'/p.m/c'    # compiled
+        assert reC ~ str
+    
+        m = reC ~ str
+        assert m.success
+        assert m.value == 'pom'
+        assert reC ~ str
+        assert (reC ~ str).success
+        assert (reC ~ str).value == 'pom'
+        
+
+        m = m.nextMatch to !
+        assert m.success
+        assert m.value == 'pam'
+        
+        m = m.nextMatch to !
+        assert m.success
+        assert m.value == 'pum'
+        
+        m = m.nextMatch to !
+        assert not m.success
+        assert not m.value.length
+        
+    
+        rex = re'/[Dd]\w+\W(p.m)/'  
+        m = rex ~ str
+        assert m.success
+        assert m.value == 'Diddly pom'
+        assert m.groups[1].captures.count == 1
+        assert m.groups[1].captures[0].value == 'pom'
+        
+        # Explicit capture flag
+        rex = re'/[Dd]\w+\W(p.m)/x' 
+        m = rex ~ str
+        assert m.success
+        assert m.value == 'Diddly pom'
+        assert m.groups[1].captures.count == 0
+        
+        rex = re'/[Dd]\w+\W(?<v>p.m)/x' 
+        m = rex ~ str
+        assert m.success
+        assert m.value == 'Diddly pom'
+        assert m.groups[1].captures.count == 1
+        assert m.groups[1].captures[0].value == 'pom'
+        

Tests/320-misc-two/410-regexp/160-regexp-lit-no-ptn-err.cobra

@@ +1 @@
+class RegexpLit
+    def main is shared
+    
+        re = re''   # .error. no pattern specified
+        re1 = re'//' # .error. no pattern specified
+        CobraCore.noOp(re, re1)

Tests/320-misc-two/410-regexp/140-regexp-lit-W.cobra

@@ +1 @@
+# .skip. Placeholder for regexp W flag suppressed pending multiline strings
+
+class ReMatch
+
+    def main is shared
+        str = '@param farethee well\n @param fare thee well\n@param ftw my darling maid'
+        
+        re = re'/^  # SOLN
+            \s*     # any whitespace
+            @param  # 
+            \s+     # 1+ whitespace
+            (.*)    # capture these
+            $       # EOLN
+            /mW'    # flags - Multiline
+
+        assert re.isMatch(str)
+        m = re.match(str)
+        assert m.success 
+        assert m.groups.count >0
+        assert m.groups[1].captures.count > 0
+        assert m.groups[1].captures[0].value == 'farethee well'

Tests/320-misc-two/410-regexp/168-regexp-lit-flag-err.cobra

@@ +1 @@
+class RegexpLit
+    def main is shared
+    
+        re = re'/foo/icsmxW'    # all the flags
+        
+        re = re'/foo/I' # .error. unrecognised Regexp flag "I" 
+        re1 = re'/q.ack/u'  # .error. unrecognised Regexp flag "u" 
+        CobraCore.noOp(re, re1)