Changeset 55 for trunk/orca/parse.c

Timestamp:

02/18/06 18:19:46 (3 years ago)

Author:

krobillard

Message:

Implemented block parse.
orEqual() now works with words.
Added orDatatype macro.

Files:

• trunk/orca/parse.c (modified) (21 diffs)

trunk/orca/parse.c

@@ -85 +85 @@
 */
 static const OValue* evalParseStr( const OValue* rit, const OValue* rend,
-                                   const OString* str, int* spos )
+                                   OIndex strN, int* spos )
 {
+    OString* str;
+    int atom;
     int pos = *spos;
 
-cont:
+match:
 
     while( rit != rend )
     {
-        switch( rit->type )
+        switch( orType(rit) )
         {
             case OT_WORD:
-                if( orAtom(rit) == OR_ATOM_OPT )
+                atom = orAtom(rit);
+
+                if( atom == OR_ATOM_OPT )
                 {
                     const OValue* r2 = rit + 1;
@@ -103 +107 @@
                         return 0;
 
-                    evalParseStr( r2, r2 + 1, str, &pos );
+                    evalParseStr( r2, r2 + 1, strN, &pos );
                     if( orErrorThrown )
                         return 0;
                     rit += 2;
                 }
-                else if( orAtom(rit) == OR_ATOM_ANY )
+                else if( atom == OR_ATOM_ANY )
                 {
                     //until [not eval-pstr second it]
@@ -126 +130 @@
                     if( orIs(r2, OT_BITSET) )
                     {
-                        const uint8_t* it  = str->byteArray + pos;
-                        const uint8_t* end = str->byteArray + str->used;
+                        const uint8_t* it;
+                        const uint8_t* end;
+
+                        str = orStringPtr(strN);
+                        it  = str->byteArray + pos;
+                        end = str->byteArray + str->used;
 
                         end = thruChars( r2, it, end );
@@ -140 +148 @@
                     }
                 }
-                else if( orAtom(rit) == OR_ATOM_SOME )
+                else if( atom == OR_ATOM_SOME )
                 {
                     const OValue* found;
-                    const OValue* rend2;
+                    const OValue* r2end;
                     const OValue* r2 = rit + 1;
 
@@ -161 +169 @@
                         blk2 = orBLOCK(r2);
                         r2    = blk2->values + r2->series.it;
-                        rend2 = blk2->values + blk2->used;
-
-                        found = evalParseStr( r2, rend2, str, &pos );
+                        r2end = blk2->values + blk2->used;
+
+                        found = evalParseStr( r2, r2end, strN, &pos );
                         if( found )
                         {
                             do
                             {
-                                found = evalParseStr( r2, rend2, str, &pos );
+                                found = evalParseStr( r2, r2end, strN, &pos );
                                 if( orErrorThrown )
                                     return 0;
@@ -182 +190 @@
                     else if( orIs(r2, OT_BITSET) )
                     {
-                        const uint8_t* it  = str->byteArray + pos;
-                        const uint8_t* end = str->byteArray + str->used;
+                        const uint8_t* it;
+                        const uint8_t* end;
+
+                        str = orStringPtr(strN);
+                        it  = str->byteArray + pos;
+                        end = str->byteArray + str->used;
 
                         end = thruChars( r2, it, end );
@@ -204 +216 @@
                     }
                 }
-                else if( orAtom(rit) == OR_ATOM_BREAK )
+                else if( atom == OR_ATOM_BREAK )
                 {
                     return rit;
                 }
-                else if( orAtom(rit) == OR_ATOM_BAR )
+                else if( atom == OR_ATOM_BAR )
                 {
                     goto complete;
                 }
-                else if( orAtom(rit) == OR_ATOM_TO )
+                else if( atom == OR_ATOM_TO )
                 {
                     int si;
@@ -220 +232 @@
                         return 0;
 
-                    if( ! orIsString(r2->type) )
-                        return 0;
-
-                    si = orFindString(str, pos, orSTRING(r2), r2->series.it);
+                    if( ! orIsString( orType(r2) ) )
+                        return 0;
+
+                    si = orFindString( orStringPtr(strN), pos,
+                                       orSTRING(r2), r2->series.it );
                     if( si > -1 )
                     {
@@ -234 +247 @@
                     }
                 }
+                else if( atom == OR_ATOM_SKIP )
+                {
+                    //if( pos >= str->used )
+                    //    return 0;
+                    ++rit;
+                    ++pos;
+                }
                 /*
-                else if( orAtom(rit) == OR_ATOM_THRU )
-                {
-                }
-                else if( orAtom(rit) == OR_ATOM_SKIP )
-                {
-                }
-                else if( orAtom(rit) == OR_ATOM_SET )
-                {
-                }
-                else if( orAtom(rit) == OR_ATOM_COPY )
+                else if( atom == OR_ATOM_THRU )
+                {
+                }
+                else if( atom == OR_ATOM_SET )
+                {
+                }
+                else if( atom == OR_ATOM_COPY )
                 {
                 }
@@ -257 +274 @@
                     if( orIs(wval, OT_BLOCK) )
                     {
+                        // Same as case OT_BLOCK below.
                         cblk = orBLOCK( wval );
                         wval = evalParseStr( cblk->values + wval->series.it,
                                              cblk->values + cblk->used,
-                                             str, &pos );
+                                             strN, &pos );
                         if( wval )
                             ++rit;
@@ -269 +287 @@
                     {
                         OString* bin = orSTRING( wval );
-                        int c = str->charArray[ pos ];
+                        int c;
+
+                        str = orStringPtr(strN);
+                        c = str->charArray[ pos ];
                         if( orBitIsSet( bin->byteArray, c ) )
                         {
@@ -294 +315 @@
 
                 orSetTF( wval, OT_STRING );
-                orSetSeries( wval, orStringN(str), pos );
+                orSetSeries( wval, strN, pos );
 
                 ++rit;
@@ -318 +339 @@
                     while( 1 )
                     {
-                        if( ! evalParseStr( r2, r2 + 1, str, &pos ) )
+                        if( ! evalParseStr( r2, r2 + 1, strN, &pos ) )
                             break;
                         ++count;
@@ -334 +355 @@
 
             case OT_CHAR:
+                str = orStringPtr(strN);
                 if( str->charArray[ pos ] == orInt(rit) )
                 {
@@ -351 +373 @@
                 found = evalParseStr( cblk->values + rit->series.it,
                                       cblk->values + cblk->used,
-                                      str, &pos );
+                                      strN, &pos );
                 if( found )
                     ++rit;
@@ -360 +382 @@
 
             case OT_PAREN:
+            {
                 orEvalBlock( orBLOCK(rit), rit->series.it );
+                if( orErrorThrown )
+                    return 0;
                 ++rit;
+            }
                 break;
 
@@ -368 +394 @@
                 OString* mstr = orSTRING(rit);
 
+                str = orStringPtr(strN);
                 /*
                 if( useCase )
@@ -383 +410 @@
 
             default:
-                orError( "invalid parse value %s", orDatatypeName(rit->type) );
+                orError( "invalid parse value %s",
+                         orDatatypeName( orType(rit) ) );
                 return 0;
         }
@@ -404 +432 @@
     {
         pos = *spos;
-        goto cont;
+        goto match;
     }
     return 0;
@@ -412 +440 @@
 /*
    strV points to string OValue.
-   ruleV points to rule block OValue.
+   rules points to rule block OValue.
 */
-static void parseStringRules( OValue* strV, OValue* ruleV, int all,
+static void parseStringRules( OValue* strV, OValue* rules, int all,
                               int useCase )
 {
-    OBlock* rblk = orBLOCK(ruleV);
-    const OValue* rit  = rblk->values + ruleV->series.it;
+    OBlock* rblk = orBLOCK(rules);
+    const OValue* rit  = rblk->values + rules->series.it;
     const OValue* rend = rblk->values + rblk->used;
-    OString* str = orSTRING(strV);
-    int si = strV->series.it;
-    int lresult = 0;
+    OIndex strN  = strV->series.n;
+    int si       = strV->series.it;
+    int lresult  = 0;
+
 
     (void) all;
     (void) useCase;
 
-    rit = evalParseStr( rit, rend, str, &si );
+    orRefAvailErr( 2 );
+    orRefPush( OT_BLOCK, rules->series.n );
+    orRefPush( OT_STRING, strN );
+
+    rit = evalParseStr( rit, rend, strN, &si );
+
+    orRefPop( 2 );
+
     if( rit )
     {
+        OString* str = orStringPtr(strN);
         if( si >= str->used )
             lresult = 1;
@@ -527 +564 @@
 
 
+/*==========================================================================*/
+
+
+/**
+  Returns index in blkV where fval is found or -1 if fval is not found.
+*/
+static int _findBlock( const OBlock* blk, OIndex pos, const OValue* fval )
+{
+    OValue* it  = blk->values + pos;
+    OValue* end = blk->values + 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->values;
+        ++it;
+    }
+    return -1;
+}
+
+
+/*
+   Returns zero if matching rule not found.
+*/
+static const OValue* evalParseBlock( const OValue* rit, const OValue* rend,
+                                     OIndex blkN, int* spos )
+{
+    OBlock* blk;
+    OValue* val;
+    int atom;
+    int pos = *spos;
+
+match:
+
+    while( rit != rend )
+    {
+        switch( orType(rit) )
+        {
+            case OT_WORD:
+                atom = orAtom(rit);
+
+                if( atom < OT_COUNT )
+                {
+                    // Datatype
+                    blk = orBlockPtr(blkN);
+                    val = blk->values + pos;
+                    if( orType(val) != orAtom(rit) )
+                    {
+                        if( orAtom(rit) == OT_NUMBER )
+                        {
+                            if( orIs(val, OT_INTEGER) || orIs(val, OT_DECIMAL) )
+                                goto datatype_match;
+                        }
+                        goto failed;
+                    }
+datatype_match:
+                    ++rit;
+                    ++pos;
+                }
+                else if( atom == OR_ATOM_OPT )
+                {
+                    const OValue* r2 = rit + 1;
+
+                    if( r2 == rend )
+                        return 0;
+
+                    evalParseBlock( r2, r2 + 1, blkN, &pos );
+                    if( orErrorThrown )
+                        return 0;
+                    rit += 2;
+                }
+                else if( atom == OR_ATOM_ANY )
+                {
+                    const OValue* r2 = rit + 1;
+
+                    if( r2 == rend )
+                        return 0;
+
+                    if( orIs(r2, OT_WORD) )
+                    {
+                        OBlock* ctxBlk;
+                        orWordVal( r2, ctxBlk, r2 );
+                    }
+
+                    if( orIs(r2, OT_BLOCK) )
+                    {
+                        const OValue* found;
+                        const OValue* r2end;
+                        OBlock* blk2;
+
+                        blk2 = orBLOCK(r2);
+                        r2    = blk2->values + r2->series.it;
+                        r2end = blk2->values + blk2->used;
+
+                        do
+                        {
+                            found = evalParseBlock( r2, r2end, blkN, &pos );
+                            if( orErrorThrown )
+                                return 0;
+                        }
+                        while( found );
+
+                        rit += 2;
+                    }
+                    else
+                    {
+                        orError( "parse any expected block" );
+                        return 0;
+                    }
+                }
+                else if( atom == OR_ATOM_SOME )
+                {
+                    const OValue* r2 = rit + 1;
+
+                    if( r2 == rend )
+                        return 0;
+
+                    if( orIs(r2, OT_WORD) )
+                    {
+                        OBlock* ctxBlk;
+                        orWordVal( r2, ctxBlk, r2 );
+                    }
+
+                    if( orIs(r2, OT_BLOCK) )
+                    {
+                        const OValue* found;
+                        const OValue* r2end;
+                        OBlock* blk2;
+
+                        blk2 = orBLOCK(r2);
+                        r2    = blk2->values + r2->series.it;
+                        r2end = blk2->values + blk2->used;
+
+                        found = evalParseBlock( r2, r2end, blkN, &pos );
+                        if( found )
+                        {
+                            do
+                            {
+                                found = evalParseBlock( r2, r2end, blkN, &pos );
+                                if( orErrorThrown )
+                                    return 0;
+                            }
+                            while( found );
+
+                            rit += 2;
+                        }
+                        else
+                        {
+                            goto failed_eval;
+                        }
+                    }
+                    else
+                    {
+                        orError( "parse some expected block" );
+                        return 0;
+                    }
+                }
+                else if( atom == OR_ATOM_BREAK )
+                {
+                    return rit;
+                }
+                else if( atom == OR_ATOM_BAR )
+                {
+                    goto complete;
+                }
+                else if( atom == OR_ATOM_TO )
+                {
+                    int si;
+                    const OValue* r2 = rit + 1;
+
+                    if( r2 == rend )
+                        return 0;
+
+                    si = _findBlock( orBlockPtr(blkN), pos, r2 );
+                    if( si < 0 )
+                        goto failed;
+
+                    pos = si;
+                    rit += 2;
+                }
+                else if( atom == OR_ATOM_SKIP )
+                {
+                    //if( pos >= ser->used )
+                    //    return 0;
+                    ++rit;
+                    ++pos;
+                }
+                /*
+                else if( atom == OR_ATOM_THRU )
+                {
+                }
+                else if( atom == OR_ATOM_SET )
+                {
+                }
+                else if( atom == OR_ATOM_COPY )
+                {
+                }
+                */
+                else
+                {
+                    const OValue* wval;
+                    const OBlock* cblk;
+
+                    orWordVal( rit, cblk, wval );
+
+                    if( orIs(wval, OT_BLOCK) )
+                    {
+                        // Same as case OT_BLOCK below.
+                        cblk = orBLOCK( wval );
+                        wval = evalParseBlock( cblk->values + wval->series.it,
+                                               cblk->values + cblk->used,
+                                               blkN, &pos );
+                        if( wval )
+                            ++rit;
+                        else
+                            goto failed_eval;
+                    }
+                    else
+                    {
+                        orError( "parse expected block" );
+                        return 0;
+                    }
+                }
+                break;
+
+            case OT_SETWORD:
+            {
+                OValue* wval;
+                OBlock* ctxBlk;
+
+                orWordVal( rit, ctxBlk, wval );
+
+                orSetTF( wval, OT_BLOCK );
+                orSetSeries( wval, blkN, pos );
+
+                ++rit;
+            }
+                break;
+
+            case OT_LITWORD:
+            {
+                blk = orBlockPtr(blkN);
+                val = blk->values + pos;
+                if( orIs(val, OT_WORD) && (orAtom(val) == orAtom(rit)) )
+                {
+                    ++rit;
+                    ++pos;
+                }
+                else
+                    goto failed;
+            }
+                break;
+
+            case OT_INTEGER:
+            {
+                const OValue* r2 = rit + 1;
+
+                if( r2 == rend )
+                    return 0;
+
+                if( orIs(r2, OT_INTEGER) )
+                {
+                    int count = 0;
+                    int maxCount = orInt(r2);
+
+                    ++r2;
+                    if( r2 == rend )
+                        return 0;
+
+                    while( 1 )
+                    {
+                        if( ! evalParseBlock( r2, r2 + 1, blkN, &pos ) )
+                            break;
+                        ++count;
+                    }
+
+                    if( orErrorThrown )
+                        return 0;
+                    if( (count >= orInt(rit)) && (count <= maxCount) )
+                        rit += 3;
+                    else
+                        goto failed;
+                }
+            }
+                break;
+#if 0
+            case OT_DATATYPE:
+            {
+                OValue* val;
+
+                blk = orBlockPtr(blkN);
+                val = blk->values + pos;
+                if( orType(val) == orDatatype(rit) )
+                {
+                    ++rit;
+                    ++pos;
+                }
+                else
+                    goto failed;
+            }
+                break;
+#endif
+            case OT_BLOCK:
+            {
+                const OValue* found;
+                const OBlock* cblk;
+
+                cblk = orBLOCK( rit );
+                found = evalParseBlock( cblk->values + rit->series.it,
+                                        cblk->values + cblk->used,
+                                        blkN, &pos );
+                if( found )
+                    ++rit;
+                else
+                    goto failed_eval;
+            }
+                break;
+
+            case OT_PAREN:
+            {
+                orEvalBlock( orBLOCK(rit), rit->series.it );
+                if( orErrorThrown )
+                    return 0;
+                ++rit;
+            }
+                break;
+
+            default:
+                orError( "invalid parse value %s",
+                         orDatatypeName( orType(rit) ) );
+                return 0;
+        }
+    }
+
+complete:
+
+    *spos = pos;
+    return rit;
+
+failed_eval:
+
+    if( orErrorThrown )
+        return 0;