root/trunk/orca/util/cbparse.c

/*============================================================================
    ORCA - CBParser
    Copyright (C) 2005-2006  Karl Robillard

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
===========================================================================*/


#include "ovalue.h"
#include "cbparse.h"


/*
   C Block Parse (CBParse) is a small module which scans a block for simple
   value patterns.  Matched results are handled by C code rather than by the
   interpreter for maximum speed.
*/


/**
  ruleSet is a series of rule-id/block pairs.
  Note that the order of rules is important.  Earlier rules will match before
  later ones.
*/
void cbp_beginParse( CBParser* cbp, OValue* it, OValue* end, OBlock* ruleSet )
{
    cbp->error     = 0;
    cbp->_blockPos = it;
    cbp->_blockEnd = end;

    // Validate ruleSet.
    // Set _rules to 0 if not valid so cbp_matchRule() will fail.
    if( (ruleSet->used < 2) || (ruleSet->used & 1) )
        cbp->_rules = 0;
    else
        cbp->_rules = ruleSet;
}


/**
  Returns pointer to matched rule-id value or zero if no match was found.
  If a rule was matched, cbp->values points to the matching values in
  the input.

  cbp->error will point to unmatched values or be zero if all data found
  matches the rules given to cbp_beginParse().
*/
OValue* cbp_matchRule( CBParser* cbp )
{
    OBlock* rule;
    OValue* rit;
    OValue* rend;
    OValue* vmatch;
    OValue* ruleEnd;
    OValue* stream;

    if( ! cbp->_rules )
        return 0;

    if( cbp->_blockPos == cbp->_blockEnd )
        return 0;

    rit  = cbp->_rules->values;
    rend = rit + cbp->_rules->used;
    for( ; rit != rend; ++rit )
    {
        ++rit;
        if( rit->type != OT_BLOCK )
        {
            cbp->_rules = 0;
            return 0;
        }

        rule = orBLOCK( rit );
        vmatch  = rule->values;
        ruleEnd = vmatch + rule->used;

        stream = cbp->_blockPos;
        for( ; vmatch != ruleEnd; ++vmatch, ++stream )
        {
            if( stream == cbp->_blockEnd )
                break;

            //if( vmatch->type == OT_ANYTYPE )
            //    continue;

            if( orIs(vmatch, OT_LITWORD) )
            {
                if( (orType(stream) != OT_WORD) ||
                    (orAtom(vmatch) != orAtom(stream)) )
                    break;
            }
            else if( orIs(vmatch, OT_WORD) )
            {
#if 0
                OContext* ctx;
                OValue* wval;

                orWordVal( vmatch, ctx, wval );

                if( orIs(wval, OT_DATATYPE) )
#else
                if( orAtom(vmatch) < OT_COUNT )
#endif
                {
#if 0
                    int dt = orInt(wval);
#else
                    int dt = orAtom(vmatch);
#endif
                    if( dt == OT_NUMBER )
                    {
                        if( (orType(stream) != OT_INTEGER) &&
                            (orType(stream) != OT_DECIMAL) )
                            break;
                    }
                    else if( dt != stream->type )
                    {
                        break;
                    }
                }
                else
                {
                    break;
                }
            }
            else if( vmatch->type != stream->type )
            {
                break;
            }
        }

        if( vmatch == ruleEnd )
        {
            cbp->values    = cbp->_blockPos;
            cbp->_blockPos = stream;
            // Return matched rule.
            return rit - 1;
        }
    }

    cbp->error = cbp->_blockPos;
    return 0;
}


/*EOF*/