Changeset 122 for trunk/thune/parse.c

Timestamp:

04/19/06 13:47:57 (3 years ago)

Author:

krobillard

Message:

Thune - Parse now similar to Orca parse.

Files:

• trunk/thune/parse.c (modified) (4 diffs)

trunk/thune/parse.c

@@ -22 +22 @@
 #include "urlan.h"
 #include "urlan_atoms.h"
-#include "charset.h"
 #include "internal.h"
 
 
+#define _errorThrown    ur_is(pe->thread->tos, UT_ERROR)
+
+
+extern int ur_matchString( const UString* strA, int iA,
+                           const UString* strB, int iB );
+extern int ur_findString( const UString* strA, int iA,
+                          const UString* strB, int iB );
+
+
+typedef struct
+{
+    UThread*   thread;
+    UCell*     rules;
+    UCellSlice input;
+    int        error;
+    int        matchCase;
+}
+StringParser;
+
+
 /*
-   Returns number of characters matched or zero if any part of the pattern
-   does not match.
+  Goto next rule; search for '|'.
 */
-static int _matchStr( UCell* patVal, UChar* sit, UChar* send )
-{
-    if( sit == send )
-        return 0;
-
-    switch( ur_type(patVal) )
-    {
-        case UT_WORD:
+static const UCell* nextRule( const UCell* it, const UCell* end )
+{
+    while( it != end )
+    {
+        if( ur_is(it, UT_WORD) && (ur_atom(it) == UR_ATOM_BAR) )
         {
-            UCell* val;
-            UBlock* blk;
-            ur_wordCell( patVal, blk, val );
-            return _matchStr( val, sit, send );
+            return it + 1;
         }
-            break;
-
-        case UT_CHAR:
-            if( ur_char(patVal) == *sit )
-                return 1;
-            break;
-
-        case UT_BLOCK:
-        {
-            int inc;
-            UChar* spos;
-            UBlock* blk;
-            UCell* cit;
-            UCell* cend;
-
-            blk = ur_block( patVal );
-            UR_ITER_BLOCK( cit, cend, blk, patVal );
-            spos = sit;
-            while( cit != cend )
-            {
-                inc = _matchStr( cit, spos, send );
-                if( ! inc )
-                    return 0;
-                spos += inc;
-                ++cit;
-            }
-            return spos - sit;
-        }
-
-        case UT_STRING:
-        {
-            UChar* spos;
-            UString* str;
-            UChar* cit;
-            UChar* cend;
-
-            str = ur_bin( patVal );
-            UR_ITER_STR( cit, cend, str, patVal );
-            spos = sit;
-            while( cit != cend )
-            {
-                if( *cit != *spos )
-                    return 0;
-                ++spos;
-                ++cit;
-            }
-            return spos - sit;
-        }
-
-        case UT_BITSET:
-        {
-            int c = *sit;
-            UBinary* bin = ur_bin( patVal );
-            if( ur_bitIsSet( bin->ptr.b, c ) )
-                return 1;
-        }
-            break;
+        ++it;
     }
     return 0;
@@ -106 +62 @@
 
 
-typedef struct
-{
-    UThread* thread;
-    UCell* rules;
-
-    // Context with token slice!
-    UContext ctx;
-    UCell* token;
-
-    // Input
-    UChar* start;
+static const uint8_t* thruChars( const UCell* bitsetVal,
+                                 const uint8_t* it,
+                                 const uint8_t* end )
+{
+    int c;
+    UBinary* bin = ur_bin(bitsetVal);
+    const uint8_t* bits = bin->ptr.b;
+    int maxC = bin->used * 8;
+
+    while( it != end )
+    {
+        c = *it;
+        if( c >= maxC )
+            break;
+        if( ! ur_bitIsSet( bits, c ) )
+            break;
+        ++it;
+    }
+    return it;
 }
-StringParser;
-
-
+
+
+/*
+   Returns zero if matching rule not found.
+*/
+static const UCell* _parseStr( StringParser* pe, const UCell* rit,
+                               const UCell* rend, UIndex* spos )
+{
+    UString* str;
+    UIndex pos = *spos;
+
+match:
+
+    while( rit != rend )
+    {
+        switch( ur_type(rit) )
+        {
+            case UT_WORD:
+                switch( ur_atom(rit) )
+                {
+                case UR_ATOM_OPT:
+                {
+                    const UCell* r2 = rit + 1;
+
+                    if( r2 == rend )
+                        return 0;
+
+                    _parseStr( pe, r2, r2 + 1, &pos );
+                    if( pe->error )
+                        return 0;
+                    rit += 2;
+                }
+                    break;
+
+                case UR_ATOM_ANY:
+                {
+                    //until [not eval-pstr second it]
+                    //it: skip it 2
+
+                    const UCell* r2 = rit + 1;
+
+                    if( r2 == rend )
+                        return 0;
+
+                    if( ur_is(r2, UT_WORD) )
+                    {
+                        UBlock* ctxBlk;
+                        ur_wordCell( r2, ctxBlk, r2 );
+                    }
+
+                    if( ur_is(r2, UT_BITSET) )
+                    {
+                        const uint8_t* it;
+                        const uint8_t* end;
+
+                        str = ur_binPtr( pe->input.n );
+                        it  = str->ptr.b + pos;
+                        end = str->ptr.b + str->used;
+
+                        end = thruChars( r2, it, end );
+                        if( end != it )
+                            pos = end - str->ptr.b;
+                        rit += 2;
+                    }
+                    else
+                    {
+                        ur_throwErr( pe->thread, UR_EX_SCRIPT,
+                                     "parse any expected bitset" );
+                        pe->error = 1;
+                        return 0;
+                    }
+                }
+                    break;
+
+                case UR_ATOM_SOME:
+                {
+                    const UCell* found;
+                    const UCell* r2end;
+                    const UCell* r2 = rit + 1;
+
+                    if( r2 == rend )
+                        return 0;
+
+                    if( ur_is(r2, UT_WORD) )
+                    {
+                        UBlock* ctxBlk;
+                        ur_wordCell( r2, ctxBlk, r2 );
+                    }
+
+                    if( ur_is(r2, UT_BLOCK) )
+                    {
+                        UBlock* blk2;
+
+                        blk2 = ur_block(r2);
+                        r2    = blk2->ptr.cells + r2->series.it;
+                        r2end = blk2->ptr.cells + blk2->used;
+
+                        found = _parseStr( pe, r2, r2end, &pos );
+                        if( found )
+                        {
+                            do
+                            {
+                                found = _parseStr( pe, r2, r2end, &pos );
+                                if( pe->error )
+                                    return 0;
+                            }
+                            while( found );
+                            rit += 2;
+                        }
+                        else
+                        {
+                            goto failed_eval;
+                        }
+                    }
+                    else if( ur_is(r2, UT_BITSET) )
+                    {
+                        const uint8_t* it;
+                        const uint8_t* end;
+
+                        str = ur_binPtr( pe->input.n );
+                        it  = str->ptr.b + pos;
+                        end = str->ptr.b + str->used;
+
+                        end = thruChars( r2, it, end );
+                        if( end == it )
+                        {
+                            rit = nextRule( rit, rend );
+                            if( ! rit )
+                                return 0;
+                        }
+                        else
+                        {
+                            pos = end - str->ptr.b;
+                            rit += 2;
+                        }
+                    }
+                    else
+                    {
+                        ur_throwErr( pe->thread, UR_EX_SCRIPT,
+                                     "parse some expected block or bitset" );
+                        pe->error = 1;
+                        return 0;
+                    }
+                }
+                    break;
+
+                case UR_ATOM_BREAK:
+                    return rit;
+                
+                case UR_ATOM_BAR:
+                    goto complete;
+
+                case UR_ATOM_TO:
+                case UR_ATOM_THRU:
+                {
+                    int si;
+                    const UCell* r2 = rit + 1;
+
+                    if( r2 == rend )
+                        return 0;
+
+                    if( ! ur_is( r2, UT_STRING ) )
+                        return 0;
+
+                    str = ur_bin(r2);
+                    si = ur_findString( ur_binPtr( pe->input.n ), pos,
+                                        str, r2->series.it );
+                    if( si > -1 )
+                    {
+                        if( ur_atom(rit) == UR_ATOM_TO )
+                            pos = si;
+                        else
+                            pos = si + str->used - r2->series.it;
+                        rit += 2;
+                    }
+                    else
+                    {
+                        goto failed;
+                    }
+                }
+                    break;
+
+                case UR_ATOM_SKIP:
+                    //if( pos >= str->used )
+                    //    return 0;
+                    ++rit;
+                    ++pos;
+                    break;
+
+                /*
+                case UR_ATOM_SET:
+                case UR_ATOM_COPY:
+                    break;
+                */
+
+                default:
+                {
+                    const UCell* wval;
+                    const UBlock* cblk;
+
+                    ur_wordCell( rit, cblk, wval );
+
+                    if( ur_is(wval, UT_CHAR) )
+                    {
+                        str = ur_binPtr( pe->input.n );
+                        if( str->ptr.c[ pos ] == ur_char(wval) )
+                        {
+                            ++rit;
+                            ++pos;
+                        }
+                        else
+                            goto failed;
+                    }
+                    else if( ur_is(wval, UT_BLOCK) )
+                    {
+                        // Same as case UT_BLOCK below.
+                        cblk = ur_block( wval );
+                        wval = _parseStr( pe,cblk->ptr.cells + wval->series.it,
+                                             cblk->ptr.cells + cblk->used,
+                                             &pos );
+                        if( wval )
+                            ++rit;
+                        else
+                            goto failed_eval;
+                    }
+                    else if( ur_is(wval, UT_BITSET) )
+                    {
+                        UString* bin = ur_bin( wval );
+                        int c;
+
+                        str = ur_binPtr( pe->input.n );
+                        c = str->ptr.c[ pos ];
+                        if( ur_bitIsSet( bin->ptr.b, c ) )
+                        {
+                            ++rit;
+                            ++pos;
+                        }
+                        else
+                            goto failed;
+                    }
+                    else
+                    {
+                        ur_throwErr( pe->thread, UR_EX_SCRIPT,
+                                     "parse expected char, block or bitset" );
+                        pe->error = 1;
+                        return 0;
+                    }
+                }
+                    break;
+                }
+                break;
+
+            case UT_SETWORD:
+            {
+                UCell* wval;
+                UBlock* ctxBlk;
+
+                ur_wordCell( rit, ctxBlk, wval );
+
+                ur_setType( wval, UT_STRING );
+                ur_setSeries( wval, pe->input.n, pos );
+
+                ++rit;
+            }
+                break;
+
+            case UT_INT:
+            {
+                const UCell* r2 = rit + 1;
+
+                if( r2 == rend )
+                    return 0;
+
+                if( ur_is(r2, UT_INT) )
+                {
+                    int count = 0;
+                    int maxCount = ur_int(r2);
+
+                    ++r2;
+                    if( r2 == rend )
+                        return 0;
+
+                    while( 1 )
+                    {
+                        if( ! _parseStr( pe, r2, r2 + 1, &pos ) )
+                            break;
+                        ++count;
+                    }
+
+                    if( pe->error )
+                        return 0;
+                    if( (count >= ur_int(rit)) && (count <= maxCount) )
+                        rit += 3;
+                    else
+                        goto failed;
+                }
+            }
+                break;
+
+            case UT_CHAR:
+                str = ur_binPtr( pe->input.n );
+                if( str->ptr.c[ pos ] == ur_char(rit) )
+                {
+                    ++rit;
+                    ++pos;
+                }
+                else
+                    goto failed;
+                break;
+
+            case UT_BLOCK:
+            {
+                const UCell* found;
+                const UBlock* cblk;
+
+                cblk = ur_block( rit );
+                found = _parseStr( pe, cblk->ptr.cells + rit->series.it,
+                                       cblk->ptr.cells + cblk->used, &pos );
+                if( found )
+                    ++rit;
+                else
+                    goto failed_eval;
+            }
+                break;
+
+            case UT_PAREN:
+            {
+                ur_eval( pe->thread, rit->series.n, rit->series.it );
+                if( _errorThrown )
+                {
+                    pe->error = 1;
+                    return 0;
+                }
+                ++rit;
+            }
+                break;
+
+            case UT_STRING:
+            {
+                UString* mstr = ur_bin(rit);
+
+                str = ur_binPtr( pe->input.n );
+                /*
+                if( pe->matchCase )
+                    pos = orMatchStringCase(str, pos, mstr, rit->series.it);
+                else
+                */
+                    pos = ur_matchString( str, pos, mstr, rit->series.it );
+
+                if( pos )
+                    ++rit;
+                else
+                    goto failed;
+            }
+                break;
+
+            default:
+                ur_throwErr( pe->thread, UR_EX_SCRIPT,
+                             "invalid parse value" );
+                             //orDatatypeName( ur_type(rit) ) );
+                pe->error = 1;
+                return 0;
+        }
+    }
+
+complete:
+
+    *spos = pos;
+    return rit;
+
+failed_eval:
+
+    if( pe->error )
+        return 0;
+
+failed:
+
+    rit = nextRule( rit, rend );
+    if( rit )
+    {
+        pos = *spos;
+        goto match;
+    }
+    return 0;
+}
+
+
+#if 0
 static const char* _parseStrFailedMessage( StringParser* pe,
                                            const UChar* it, const UChar* end )
@@ -129 +478 @@
     ur_strCat( str, "parse failed at \"", 17 );
 
-    ur_arrayReserve( str, sizeof(UChar), str->used + (end - it) + 1 );
+    ur_arrayReserve( str, sizeof(UChar), str->used + (end - it) + 2 );
     dest = str->ptr.c + str->used;
     while( it != end )
@@ -136 +485 @@
             break;
         *dest++ = *it++;
-        ++str->used;
-    }
-    *dest = '"';
+        //++str->used;
+    }
+    *dest++ = '"';
+    *dest   = '\0';
 
     return str->ptr.c;
 }
-
-
-static void _parseString( StringParser* pe )
-{
-    UChar* sit;
-    UChar* send;
-    UCell* rules;
+#endif
+
+
+#if 0
+static void parseString( UCell* ser, UCell* rules, int all, int useCase )
+{
+    UBinary* custom;
+    uint8_t* delim;
+    const char* cp;
+    const char* end;
+    const char* sstart;
     UBlock* rblk;
-    UCell* rit;
-    UCell* rend;
-    UCell* token;
-    UAtom atom;
-    int mc;
-    //UArray stack;
-
-    //ur_arrayInit( &stack, sizeof(void*), 16 );
-
-    token = pe->token;
-
-    sit  = pe->start + token->slice.it;
-    send = pe->start + token->slice.end;
-
-restart:
-
-    token->slice.it = sit - pe->start;
-
-    rules = pe->rules;
-    rblk  = ur_block( rules );
-
-    if( sit == send )
-        goto cleanup;
-
-pattern:
-
-    UR_ITER_BLOCK( rit, rend, rblk, rules );
-
-    while( 1 )
-    {
-        while( rit != rend )
+    UIndex rblkN;
+    UString* str = ur_bin(ser);
+
+    (void) useCase;
+
+    orRefAvailErr( 2 );
+    orRefPush( UT_STRING, ser->index );
+
+    rblk  = orMakeBlock( 0 );
+    rblkN = orBlockN( rblk );
+
+    orRefPush( UT_BLOCK, rblkN );
+
+    if( ur_is(rules, UT_STRING) )
+    {
+        custom = orMakeCharset( ur_bin(rules), rules->series.it );
+        delim = custom->ptr.b;
+        if( ! all )
         {
-            if( ur_is(rit, UT_WORD) )
-            {
+            cp = "\t\n\r ,;";
+            while( *cp )
+            {
+                orSetBit( delim, *cp );
+                ++cp;
+            }
+        }
+        orRefPush( UT_STRING, orStringN( custom ) );
+    }
+    else
+    {
+        custom = 0;
+        delim = (uint8_t*) memAlloc(32);
+        memCpy( delim, charset_white, 32 );
+        orSetBit( delim, ',' );
+        orSetBit( delim, ';' );
+    }
+
+
+    assert( ser->series.it <= str->used );
+
+    cp  = str->ptr.c + ser->series.it;
+    end = str->ptr.c + str->used;
+    sstart = cp;
+
+    while( cp != end )
+    {
+        int c = *cp;
+        if( ur_bitIsSet(delim, c) )
+        {
+            if( cp > sstart )
+            {
+                orAppendString( rblk, orMakeCString(sstart, cp-sstart) );
+            }
+            sstart = cp + 1;
+        }
+        ++cp;
+    }
+
+    if( cp > sstart )
+    {
+        orAppendString( rblk, orMakeCString(sstart, cp-sstart) );
+    }
+
+    if( custom )
+    {
+        orRefPop( 1 );
+        orArrayFree( custom );  // Garbage collection will free this later.
+    }
+    else
+    {
+        memFree( delim );
+    }
+
+    orRefPop( 2 );
+    orResultBLOCK( rblkN );
+}
+#endif
+
+
+/*==========================================================================*/
+
+
+#if 0
+/**
+  Returns index in blkV where fval is found or -1 if fval is not found.
+*/
+static int _findBlock( const UBlock* blk, UIndex pos, const UCell* fval )
+{
+    UCell* it  = blk->ptr.cells + pos;
+    UCell* end = blk->ptr.cells + blk->used;
+
+    // TODO: If fval is block then all values must match.
+
+    assert( pos <= blk->used );
+
+    while( it != end )
+    {
+        if( orEqual(it, fval) )
+            return it - blk->ptr.cells;
+        ++it;
+    }
+    return -1;
+}
+
+
+/*