Changeset 84

Timestamp:

12/17/05 09:09:42 (3 years ago)

Author:

pragma

Message:

Updated the bejezus out of this thing.

Currently Supported

• character classes (including inverse char classes via [^...])
  
• match one or more (+)
  
• match zero or more (*)
  
• match zero or one (?)
  
• escape sequences
  
• whitespace matching (ws chars are treated literally right now)
  
• {n} and {n,m} predicates
  
• at the start of an expression
  
• $ at the end of an expression
  
• grouping via ()
  
• most standard escape sequences
  
• union operator (outside of parens)
  

Files:

• trunk/meta/regex.d (modified) (12 diffs)
• trunk/meta/regexPredicate.d (modified) (4 diffs)

trunk/meta/regex.d

@@ -31 +31 @@
-    
-    --------------------
- *world
+\s*\w*
-    writefln("matches: %s",exp("hello    world");
-    --------------------
@@ -38 +38 @@
-    portions of your expression, which make up the runtime expression engine.  The
-    resulting generated code set and call tree are absolutely minimalistic and match
-one-for-on
-
+with as few productions as possibl
+   
-    Currently Supported
-
+ (including inverse char classes via [^...])
-    - match one or more (+)
-    - match zero or more (*)
-    - match zero or one (?)
-    
-    Planned
-    - escape sequences
-    - whitespace matching (ws chars are treated literally right now)
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
-    
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
-*/
-module meta.regex;
@@ -82 +76 @@
-
-import meta.regexPredicate;
+
+template getAt(char[] str,uint index){
+    const char getAt = str[index];
+}
+
+template first(char[] str){
+    const char first = str[0];
+}
+
+template last(char[] str){
+    const char last = getAt!(str,strlen!(str)-1);
+}
-
-template isSpecial(char[] pattern){
@@ -91 +97 @@
-        pattern[0] == '[' ||
-        pattern[0] == '{' ||
-
-
+
+
+
+
+
+
-        pattern[0] == '\\'  
-    ){
@@ -116 +126 @@
-}
-
+/// parses up to and including terminator.  Returns everything up to terminator.
+template parseUntil(char[] pattern,char terminator,bit fuzzy=false){
+    static if(strlen!(pattern) > 0){
+        static if(pattern[0] == '\\'){
+            static if(strlen!(pattern) > 1){
+                const char[] nextSlice = sliceheadoff!(pattern,2);
+                alias .parseUntil!(nextSlice,terminator,fuzzy) next;
+                const char[] token = slice!(pattern,0,2) ~ next.token;  
+                const uint consumed = next.consumed+2;
+            }
+            else{
+                pragma(msg,"Error: exptected character to follow \\");
+                static assert(false);
+            }
+        }
+        else static if(pattern[0] == terminator){
+            const char[] token="";
+            const uint consumed = 1;
+        }
+        else{
+            const char[] nextSlice = sliceheadoff!(pattern,1);
+            alias .parseUntil!(nextSlice,terminator,fuzzy) next;
+            const char[] token = slice!(pattern,0,1) ~ next.token;
+            const uint consumed = next.consumed+1;
+        }
+    }
+    else static if(fuzzy){
+        const char[] token = "";
+        const uint consumed = 0;
+    }
+    else{
+        pragma(msg,"Error: exptected " ~ makechar!(terminator) ~ " to terminate group expression");
+        static assert(false);
+    }           
+}
+
+// shim for parseUint
+template charToUint(char[] value){
+    const uint charToUint = value[0];
+}
+
+template parseUint(char[] pattern,uint prev=0){
+    static if(strlen!(pattern) > 0){
+        static if(pattern[0] >= '0' && pattern[0] <= '9'){
+            const uint thisValue = (charToUint!(pattern)-'0') + prev*10;
+            alias .parseUint!(sliceheadoff!(pattern,1),thisValue) next;
+            const uint consumed = next.consumed+1;
+            const uint value = next.value;
+        }
+        else{
+            const uint consumed = 0;
+            const uint value = prev;
+        }
+    }
+    else{
+        const uint consumed = 0;
+        const uint value = prev;
+    }           
+}
+
-template regexCompileCharClassRecurse(alias termFn,char[] pattern){
-    static if(strlen!(pattern) > 0){
@@ -121 +191 @@
-            debug pragma(msg,"REMAINING: " ~ pattern);
-            
-
+2
-            alias testOr!(termFn,next.fn,pattern) fn;
-            const uint consumed = next.consumed;
@@ -137 +207 @@
-}
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    static if(strlen!(pattern) > 0){
-        static if(pattern[0] == ']'){
@@ -143 +279 @@
-            const uint consumed = 0;
-        }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-}
-
@@ -218 +338 @@
-            const uint consumed = 1;
-        }
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        else{
-            alias test fn;
@@ -230 +364 @@
-}
-
+template regexCompileEscape(char[] pattern){
+    static if(strlen!(pattern) > 0){
+        static if(pattern[0] == '\\'){
+            alias testChar!("\\") fn;
+        }       
+        //TODO: word boundary (/b) and non-word boundary (/B)
+        //TODO: /d (decimal) and /o (octal)?
+        else static if(pattern[0] == 'd'){
+            // numeric chars
+            alias testRange!("0","9") fn;
+        }
+        else static if(pattern[0] == 'D'){
+            // non numeric chars
+            alias testCharInverse!(testRange!("0","9"),pattern) fn;
+        }
+        else static if(pattern[0] == 'f'){
+            // form feed
+            alias testChar!("\f") fn;
+        }       
+        else static if(pattern[0] == 'n'){
+            // newline
+            alias testChar!("\n") fn;
+        }
+        else static if(pattern[0] == 'r'){
+            // carriage return
+            alias testChar!("\r") fn;
+        }
+        else static if(pattern[0] == 's'){
+            // whitespace char
+            alias testRange!("\x00","\x20") fn;
+        }
+        else static if(pattern[0] == 'S'){
+            //non-whitespace char
+            alias testCharInverse!(testRange!("\x00","\x20"),pattern) fn;
+        }
+        else static if(pattern[0] == 't'){
+            //tab   
+            alias testChar!("\t") fn;
+        }
+        else static if(pattern[0] == 'v'){
+            //vertical tab
+            alias testChar!("\v") fn;
+        }
+        else static if(pattern[0] == 'w'){
+            //word char
+            alias testWordChar!() fn;
+        }
+        else static if(pattern[0] == 'W'){
+            alias testCharInverse!(testWordChar!()) fn;
+        }
+        else{
+            alias testChar!(slice!(pattern,0,1)) fn;
+        }
+        const uint consumed = 1;
+    }
+    else{
+        pragma(msg,"Error: expected char following '\\'");
+        static assert(false);
+    }
+}
+
-/// recursive portion of regexCompile - shim to work around alias scope issue
-template regexCompileRecurse(alias term,char[] pattern){
@@ -244 +439 @@
-
-/// recursive descent parser for regex strings
+//TODO: install pipe operator here and give regexCompile the 'consumed' protocol to make
+// partial passes of the pattern possible
-template regexCompile(char[] pattern){
-    debug pragma(msg,"PATTERN: " ~ pattern);
-    static if(strlen!(pattern) > 0){
-        static if(pattern[0] == '['){
-
+
+
-            const char[] token = slice!(pattern,0,charClass.consumed+2);
-            const char[] next = slice!(pattern,charClass.consumed+2,strlen!(pattern));
-            alias charClass.fn test;
-        }
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-            static assert(false);
-        }
-
-
-
+
+
+
+
+
-            const char[] token = parseTextToken!(pattern);
+            static assert(strlen!(token) > 0);
-            const char[] next = slice!(pattern,strlen!(token),strlen!(pattern));
-            alias testText!(token) test;
@@ -280 +497 @@
-}
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    //TODO: parse support for unions (another parser layer most likely)
-
-
+
+
+
+
+
+

trunk/meta/regexPredicate.d

@@ -30 +30 @@
-import meta.string;
-
+/* TODO: support all of these
+exec
+
+    A regular expression method that executes a search for a match in a string. It returns an array of information.
+
+test
+
+    A regular expression method that tests for a match in a string. It returns true or false.
+
+match
+
+    A String method that executes a search for a match in a string. It returns an array of information or null on a mismatch.
+
+search
+
+    A String method that tests for a match in a string. It returns the index of the match, or -1 if the search fails.
+
+replace
+
+    A String method that executes a search for a match in a string, and replaces the matched substring with a replacement substring.
+
+split
+
+    A String method that uses a regular expression or a fixed string to break a string into an array of substrings.
+*/
+
-//match routines
-alias char[][] function(char[] str) MatchPredicate;
-alias const noMatch = (char[][]).init ;
-
+// unions the results of two matches together
-template matchUnion(alias firstMatch,alias secondMatch,char[] key){
-    char[][] matchUnion(char[] str){
-
-
+
-        results ~= secondMatch(str);
-        return results;
@@ -43 +69 @@
-}
-
-
+
-template matchTest(alias testPredicate,char[] key){
-    char[][] matchTest(char[] str){
-        char[][] results;
-        int result = testPredicate(str);
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-            results ~= str[0..result];
-        }
@@ -170 +257 @@
-
-template testAny(){
-char[]
+int
-        if(str.length == 0) return testFail;
-        //TODO: check for newline (some regexps dont' test this)
@@ -187 +274 @@
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+