root/trunk/thune/make.c

/*============================================================================
    Thune Interpreter
    Copyright (C) 2005-2007  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 <stdio.h>
#include <assert.h>
#include "urlan.h"
#include "urlan_atoms.h"
#include "os.h"
#include "internal.h"
#include "charset.h"
#ifdef UR_CONFIG_LIST
#include "list.h"
#endif
#ifdef UR_CONFIG_HASHMAP
#include "hashmap.h"
#endif


//#define GC_STRESS_TEST  1


extern int64_t ur_stringToInt( const char*, const char*, const char** );
extern int64_t ur_hexToInt( const char*, const char*, const char** );
extern double ur_stringToDec( const char*, const char*, const char** );

extern UContext ur_thrGlobal;


extern void ur_internDefault( UThread* ut, UCell* wc, UAtom atom,
                              UCell* cbot, UCell* ctop );

/*
   wc->flags, wc->word wordBlk, valBlk, & index are set.
*/
static void ur_internGlobal( UThread* ut, UCell* wc, UAtom atom )
{
    UBlock* cblk = tBlockPtr( BLK_CTX_STACK );
    ur_internDefault( ut, wc, atom, cblk->ptr.cells,
                                    cblk->ptr.cells + cblk->used );
}


static UArray* _nextFree( UGCArray* gc )
{
    UArray* next;

    next = ((UArray*) gc->arr.ptr.v) + gc->freeList;

    assert( gc->freeList > -1 );
    assert( next->avail == -1 );
    assert( next->ptr.v == 0 );

    gc->freeList = next->used;
    gc->freeCount--;

    return next;
}


/**
  Size is the number of cells to reserve.  Used is set to 0.
*/
UIndex ur_makeBlockT( UThread* ut, int size, UBlock** blkPtr )
{
    UBlock* ptr;
    UArray* ca = &ut->blocks.arr;

#ifdef GC_STRESS_TEST
    if( ut->flags & UR_THREAD_GC )
        ur_recycle( ut );
#endif

    if( ut->blocks.freeCount )
    {
        ptr = (UBlock*) _nextFree( &ut->blocks );
        goto init;
    }

#ifndef GC_STRESS_TEST
    if( (ca->used == ca->avail) && (ut->flags & UR_THREAD_GC) )
    {
        ur_recycle( ut );
        if( ut->blocks.freeCount )
        {
            ptr = (UBlock*) _nextFree( &ut->blocks );
            goto init;
        }
    }
#endif

    UR_EXPAND_1( UBlock, ca, ptr );

init:

    ur_arrayInit( ptr, sizeof(UCell), size );
    if( blkPtr )
        *blkPtr = ptr;
    return ur_blockN( ptr );
}


/**
  Size is the number of bytes to reserve.  Used is set to 0.
*/
UIndex ur_makeBinaryT( UThread* ut, int size, UBinary** binPtr )
{
    UBinary* ptr;
    UArray* ca = &ut->bin.arr;

#ifdef GC_STRESS_TEST
    if( ut->flags & UR_THREAD_GC )
        ur_recycle( ut );
#endif

    if( ut->bin.freeCount )
    {
        ptr = (UBinary*) _nextFree( &ut->bin );
        goto init;
    }

#ifndef GC_STRESS_TEST
    if( (ca->used == ca->avail) && (ut->flags & UR_THREAD_GC) )
    {
        ur_recycle( ut );
        if( ut->bin.freeCount )
        {
            ptr = (UBinary*) _nextFree( &ut->bin );
            goto init;
        }
    }
#endif

    UR_EXPAND_1( UBinary, ca, ptr );

init:

    ur_arrayInit( ptr, sizeof(char), size );
    if( binPtr )
        *binPtr = ptr;
    return ur_binN( ptr );
}


/*
   Returns zero if cell can not be converted.
*/
UIndex ur_makeBinaryFrom( UThread* ut, const UCell* cell )
{
    uint8_t* cpA;
    uint8_t* cpB;
    UIndex binN = 0;

    if( ur_binaryMem( ut, cell, &cpA, &cpB ) )
    {
        int size;
        UBinary* bin;

        size = cpB - cpA;
        binN = ur_makeBinary( size, &bin );
        if( size )
        {
#ifndef __BIG_ENDIAN__
            if( ur_is(cell, UT_STRING) && (ur_encoding(cell) == UR_ENC_UCS2) )
                memSwab( cpA, bin->ptr.b, size );
            else
#endif
                memCpy( bin->ptr.b, cpA, size );

            bin->used = size;
        }
    }

    return binN;
}


const uint8_t* ur_readBinary( UBinary* bin, const uint8_t* it,
                                            const uint8_t* end )
{
    int c;
    int byte;
    int hi;
    uint8_t* out;

    ur_arrayReserve( bin, 1, bin->used + (end - it) / 2 );
    out = bin->ptr.b + bin->used;

    byte = hi = 0;

    while( it != end )
    {
        c = *it;
        if( ur_bitIsSet( charset_hex, c ) )
        {
            if( (c >= '0') && (c <= '9') )
                byte |= c - '0';
            else if( (c >= 'a') && (c <= 'f') )
                byte |= c - 'a' + 10;
            else if( (c >= 'A') && (c <= 'F') )
                byte |= c - 'A' + 10;

            if( hi )
            {
                *out++ = byte;
                byte = hi = 0;
            }
            else
            {
                byte <<= 4;
                hi = 1;
            }
        }
        else if( ! ur_bitIsSet( charset_white, c ) )
        {
            break;
        }
        ++it;
    }

    bin->used = out - bin->ptr.b;
    return it;
}


/**
  \param size  Number of bytes to allocate.  If non-zero, retp->ptr will
               point to the new buffer.  If zero, retp->ptr will be zero.
  \param retp  If non-zero, it will be set to the new resource.

  Only the UResource dataType member is used by the system.  The rest of the
  structure may be used as the caller sees fit.

  If the size is non-zero, then the caller is responsible for calling
  memFree() with the retp->ptr.  This is normally done in the datatype
  gcDestroyResource method.
*/
UIndex ur_makeResourceT( UThread* ut, int dataType, int size,
                         UResource** retp )
{
    UResource* buf;
    UGCArray* gc = &ut->resources;
    UArray* ca = &gc->arr;

#ifdef GC_STRESS_TEST
    if( ut->flags & UR_THREAD_GC )
        ur_recycle( ut );
#endif

    if( ut->resources.freeCount )
    {
#ifndef GC_STRESS_TEST
getFree:
#endif
        buf = ((UResource*) ca->ptr.v) + gc->freeList;

        assert( gc->freeList > -1 );
        assert( buf->dataType == UT_UNSET );

        gc->freeList = buf->link;
        gc->freeCount--;

        goto init;
    }

#ifndef GC_STRESS_TEST
    if( (ca->used == ca->avail) && (ut->flags & UR_THREAD_GC) )
    {
        ur_recycle( ut );
        if( ut->resources.freeCount )
            goto getFree;
    }
#endif

    UR_EXPAND_1( UResource, ca, buf );

init:

    buf->dataType = dataType;
    buf->ptr      = size ? memAlloc( size ) : 0;

    if( retp )
        *retp = buf;

    return buf - ((UResource*) ca->ptr.v);
}


/**
   Make context with wordCount reserved (used set to zero).
*/
void ur_makeContextT( UThread* ut, UContext* ctx, int wordCount )
{
    UBlock* ptrA;
    UBlock* ptrB;
    UArray* ca = &ut->blocks.arr;

#ifdef GC_STRESS_TEST
    if( ut->flags & UR_THREAD_GC )
        ur_recycle( ut );
#endif

    if( ut->blocks.freeCount > 1 )
    {
        ptrA = (UBlock*) _nextFree( &ut->blocks );
        ptrB = (UBlock*) _nextFree( &ut->blocks );
        goto init;
    }

#ifndef GC_STRESS_TEST
    if( (ca->used == ca->avail) && (ut->flags & UR_THREAD_GC) )
    {
        ur_recycle( ut );
        if( ut->blocks.freeCount > 1 )
        {
            ptrA = (UBlock*) _nextFree( &ut->blocks );
            ptrB = (UBlock*) _nextFree( &ut->blocks );
            goto init;
        }
    }
#endif

    ur_arrayReserve( ca, sizeof(UBlock), ca->used + 2 );
    ptrA = ((UBlock*) (ca->ptr.v)) + ca->used;
    ptrB = ptrA + 1;
    ca->used += 2;

init:

    ur_arrayInit( ptrA, sizeof(UCell), wordCount );
    ur_arrayInit( ptrB, sizeof(UCell), wordCount );

    ur_initType( ctx, UT_CONTEXT );
    ctx->ctx.wordBlk     = ur_blockN( ptrA );
    ctx->ctx.valBlk      = ur_blockN( ptrB );
    ctx->ctx.protoValBlk = ctx->ctx.valBlk;
}


/*
   Create context from initializer block.
   protoCtx may be zero.
   Caller must hold init and protoCtx (if non-zero) from GC.
*/
static void _makeContextProto( UThread* ut, UContext* res,
                               const UCell* init, const UCell* protoCtx )
{
    if( init && ur_is(init, UT_BLOCK) )
    {
        int size = 0;
        UBlock* blk;
        UCell* it;
        UCell* start;
        UCell* end;

        blk = ur_blockPtr( init->series.n );
        UR_ITER_BLOCK( start, end, blk, init )

        it = start;

        if( protoCtx )
        {
            // Check if prototype must be extended with new words.

            while( it != end )
            {
                if( ur_is(it, UT_SETWORD) )
                {
                    if( ur_lookup(protoCtx, ur_atom(it)) < 0 )
                        ++size;
                }
                ++it;
            }

            if( size )
            {
                UIndex pwN;
                UIndex pvN;
                UCell* rend;
                UBlock* rblk;

                // Keep indices in case protoCtx == res
                pwN = protoCtx->ctx.wordBlk;
                pvN = protoCtx->ctx.valBlk;

                blk  = ur_blockPtr( pvN );
                size += blk->used;

                ur_makeContext( res, size );

                // Copy value block.

                blk  = ur_blockPtr( pvN );      // re-acquire
                rblk = ur_blockPtr( res->ctx.valBlk );
                rblk->used = size;
                ur_copyCells( blk->ptr.cells,
                              blk->ptr.cells + blk->used,
                              rblk->ptr.cells );
#if 0
                // Deep copy
                it   = rblk->ptr.cells;
                rend = rblk->ptr.cells + size;
                while( it != rend )
                {
                    ur_clone( ut, it, UR_COPY_ALL, 2 );
                    ++it;
                }
#endif

                // Init new words to none.

                it   = rblk->ptr.cells + blk->used;
                rend = rblk->ptr.cells + size;
                while( it != rend )
                {
                    ur_initType( it, UT_NONE );
                    ++it;
                }

                // Copy word block.

                blk  = ur_blockPtr( pwN );
                rblk = ur_blockPtr( res->ctx.wordBlk );
                rblk->used = blk->used;
                ur_copyCells( blk->ptr.cells,
                              blk->ptr.cells + blk->used,
                              rblk->ptr.cells );
            }
            else
            {
                // No new words in init block; clone to share word block.

                if( res != protoCtx )
                {
                    ur_copyCell( res, *protoCtx );
                }
                ur_clone( ut, res, size, 1 );
                return;
            }
        }
        else
        {
            while( it != end )
            {
                if( ur_is(it, UT_SETWORD) )
                    ++size;
                ++it;
            }

            ur_makeContext( res, size );
        }

        it = start;
        while( it != end )
        {
            if( ur_is(it, UT_SETWORD) )
                ur_internWord( res, it->word.atom );
            ++it;
        }
    }
}


/*--------------------------------------------------------------------------*/


#define ESCAPE_CHAR     '^'


static int toHex( int n )
{
    if( (n >= '0') && (n <= '9') )
        return n - '0';
    if( (n >= 'a') && (n <= 'f') )
        return n - 'a' + 10;
    if( (n >= 'A') && (n <= 'F') )
        return n - 'A' + 10;
    return -1;
}


/*
  Returns non-zero if identical up to end of either string.
*/
int memEqual( const char* a, const char* b, int len )
{
    const char* end = a + len;
    while( a != end )
    {
        if( *a != *b )
            return 0;
        ++a;
        ++b;
    }
    return 1;
}


/* Returns -1 if not special */
static int _translateSpecialSeq( const char* cp, const char* end )
{
    int len;
    len = end - cp;
    if( len == 2 )
    {
        len = toHex( cp[0] );
        if( len > -1 )
        {
            int d2 = toHex( cp[1] );
            if( d2 > -1 )
                return (len << 4) + d2;
        }
    }
    else if( len == 3 )
    {
        if( memEqual( cp, "tab", 3 ) )
            return '\t';
        if( memEqual( cp, "esc", 3 ) )
            return 27;
    }
    else if( len == 4 )
    {
        if( memEqual( cp, "line", 4 ) )
            return '\n';
        if( memEqual( cp, "page", 4 ) )
            return '\f';
        if( memEqual( cp, "back", 4 ) )
            return '\b';
        if( memEqual( cp, "bell", 4 ) )
            return '\a';
        if( memEqual( cp, "null", 4 ) )
            return '\0';
    }
    return -1;
}


/**
  Returns -1 if failed.
*/
int ur_escapedCharacter( const uint8_t** cp, const uint8_t* end )
{
    int val;
    const uint8_t* it = *cp;

    if( it == end )
        return -1;

    switch( *it )
    {
        case '0':
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
            val = *it - '0';
            break;

        case 'A':
        case 'B':
        case 'C':
        case 'D':
        case 'E':
        case 'F':
            val = *it - 'A' + 10;
            break;

        case 'a':
        case 'b':
        case 'c':
        case 'd':
        case 'e':
        case 'f':
            val = *it - 'a' + 10;
            break;

        case '/':
            val = '\n';
            break;

        case '-':
            val = '\t';
            break;

        case '(':
        {
            const uint8_t* pend;
            pend = ++it;
            while( pend != end )
            {
                if( *pend == ')' )
                    break;
                ++pend;
            }
            if( pend == end )
                return -1;
            val = _translateSpecialSeq( (char*) it, (char*) pend );
            it = pend;
        }
            break;

        default:
            val = *it;
            break;
    }

    *cp = ++it;
    return val;
}


/*
   Convert UTF-8 to UCS-2
*/
static void _makeString16( UBinary* str, const uint8_t* cp, int len )
{
    uint16_t  ch;
    uint16_t* out;
    const uint8_t* end;

    ur_arrayReserve( str, 1, len * sizeof(uint16_t) );
    out = str->ptr.u16;

    end = cp + len;
    while( cp != end )
    {
        ch = *cp++;

        if( ch <= 0x7f )
        {
            *out++ = ch;
        }
        else if( ch >= 0xc2 && ch <= 0xdf )
        {
            if( cp != end )
            {
                *out++ = ((ch & 0x1f) << 6) | (*cp & 0x3f);
                ++cp;
            }
        }
        else if( ch >= 0xe0 && ch <= 0xef )
        {
            if( (end - cp) < 2 )
                break;
            *out++ = ((ch    & 0x0f) << 12) |
                     ((cp[0] & 0x3f) <<  6) |
                      (cp[1] & 0x3f);
            cp += 2;
        }
        else if( ch >= 0xf0 && ch <= 0xf3 )
        {
            if( (end - cp) < 3 )
                break;
            *out++ = 0;     // Only handle UCS-2
            cp += 3;
        }
    }

    str->avail /= 2;
    str->used = out - str->ptr.u16;
}


/**
  \param res  Result cell.
  \param text UTF-8 string.
  \param len  Byte length of string.  If len is less than zero then the
              length is automatically determined by looking for a NULL
              terminator.

  Special characters are translated.
*/
UString* ur_makeStringT( UThread* ut, UCell* res, const char* text, int len )
{
    UIndex strN;
    UBinary* str;
    const uint8_t* txt = (const uint8_t*) text;
    const uint8_t* cp;
    const uint8_t* end;
    uint8_t* out;
    unsigned int ch;

    if( len == 0 )
    {
        strN = ur_makeBinary( 0, 0 );
        goto init;
    }

    if( len < 0 )
    {
        cp = txt;
        while( *cp )
            ++cp;
        len = cp - txt;
    }

    strN = ur_makeBinary( len + UR_CTERM_LEN, &str );

    cp  = txt;
    end = txt + len;
    out = str->ptr.b;
    while( cp != end )
    {
        if( *cp == ESCAPE_CHAR )
        {
            ++cp;
            *out++ = ur_escapedCharacter( &cp, end ); 
        }
        else
        {
            ch = *cp++;
            if( ch > 0x7f )
            {
                if( ch <= 0xdf )
                {
                    // If the UTF-8 value is in the Latin-1 range then
                    // stay with an 8-bit string.
                    ch = ((ch & 0x1f) << 6) | (*cp & 0x3f);
                    if( ch < 256 )
                    {
                        ++cp;
                        goto output_char;
                    }
                }
                _makeString16( str, txt, len );
                ur_initString( res, strN, 0 );
                ur_setEncoding( res, UR_ENC_UCS2 );
                return str;
            }
output_char:
            *out++ = ch;
        }
    }

    str->used = out - str->ptr.b;
    str->ptr.b[ str->used ] = '\0';

init:

    ur_initString( res, strN, 0 );
    return str;
}


/*--------------------------------------------------------------------------*/


void _convertToDecimalVector( UArray* arr )
{
    int32_t* it  = arr->ptr.i;
    int32_t* end = it + arr->used;

    while( it != end )
    {
        *((float*) it) = (float) *it;
        ++it;
    }
}


UIndex ur_makeVectorT( UThread* ut, int size, UArray** ptr )
{
    UIndex binN;
    UArray* bin;

    binN = ur_makeBinary( size * sizeof(int32_t), &bin );
    bin->avail /= sizeof(int32_t);

    if( ptr )
        *ptr = bin;

    return binN;
}


#define BE32_TO_INT(bp)  (bp[0] << 24 | bp[1] << 16 | bp[2] << 8 | bp[3])
#define LE32_TO_INT(bp)  (bp[3] << 24 | bp[2] << 16 | bp[1] << 8 | bp[0])

static inline void binaryToVectorI( int32_t* it, int32_t* end,
                                    const uint8_t* bp )
{
    while( it != end )
    {
        *it++ = BE32_TO_INT(bp);
        bp += 4;
    }
}


// Returns zero if make failed.
UIndex ur_makeVectorCell( UThread* ut, const UCell* from, UCell* res ) 
{
    UArray* bin;
    UIndex binN = 0;
    int vtype = UT_INT;

    if( ur_is(from, UT_BLOCK) )
    {
        UBlock* blk;
        UCell* it;
        UCell* end;

        blk = ur_block( from );
        UR_ITER_BLOCK( it, end, blk, from )

        binN = ur_makeVector( end - it, &bin );

        while( it != end )
        {
            if( ur_is(it, UT_INT) )
            {
                bin->ptr.i[ bin->used ] = ur_int(it);
                ++bin->used;
            }
            else if( ur_is(it, UT_DECIMAL) )
            {
                goto decimal;
            }
            ++it;
        }
        goto init;

decimal:

        vtype = UT_DECIMAL;
        _convertToDecimalVector( bin );

        while( it != end )
        {
            if( ur_is(it, UT_DECIMAL) )
            {
                bin->ptr.f[ bin->used ] = (float) ur_decimal(it);
                ++bin->used;
            }
            else if( ur_is(it, UT_INT) )
            {
                bin->ptr.f[ bin->used ] = (float) ur_int(it);
                ++bin->used;
            }
            ++it;
        }
    }
    else if( ur_is(from, UT_BINARY) )
    {
        uint8_t* cpA;
        uint8_t* cpB;
        UArray* vec;
        int len;

        ur_binaryMem( ut, from, &cpA, &cpB );
        len = (cpB - cpA) / 4;
        binN = ur_makeVector( len, &vec );
        if( cpA )
        {
            vec->used = len;
            binaryToVectorI( vec->ptr.i, vec->ptr.i + len, (uint8_t*) cpA );
        }
    }
    else if( ur_is(from, UT_INT) )
    {
        binN = ur_makeVector( ur_int(from), 0 );
    }

    if( binN )
    {
init:
        ur_initVector(res, vtype, binN, 0);
        return binN;
    }

    return 0;
}


/*--------------------------------------------------------------------------*/


#if 0
typedef struct
{
    UAtom    name;
    uint16_t index;
    UAtom    ctype;
}
UStructField;


/*
   [field1 type1  field2 type2 ...]  
*/
UIndex ur_makeStructCell( const UCell* from, UCell* res ) 
{
    UArray* bin;
    UIndex binN = 0;

    if( ur_is(from, UT_BLOCK) )
    {
        UBlock* blk;
        UCell* it;
        UCell* end;
        int count;
        UAtom wrd;

        blk = ur_block( from );
        UR_ITER_BLOCK( it, end, blk, from )

        wrd = 0;
        count = 0;

        while( it != end )
        {
            if( ur_is(it, UT_WORD) )
            {
                if( count & 1 )
                {
                    wrd = ur_atom(it);
                }
                else
                {
                    switch( ur_atom(it) )
                    {
                        case UT_CHAR:
                            break;
                        case UT_INT:
                            break;
                        case UT_INT64:
                            break;
                        case UT_DECIMAL:
                            break;
                        case UT_VECTOR:
                            break;
                    }
                }
                ++count;
            }

            ++it;
        }

        binN = ur_makeBinary( end - it, &bin );
    }
    //else if( ur_is(from, UT_STRUCT) ) { }

    if( binN )
    {
        ur_initType(res, UT_STRUCT);
        ur_setSeries(res, binN, 0);
        return binN;
    }

    return 0;
}
#endif


/*--------------------------------------------------------------------------*/


static void _setBitsetBin( UThread* ut, uint8_t* bits, const UCell* from )
{
    uint8_t* it;
    uint8_t* end;
    UBinary* src = ur_bin(from);

    UR_ITER_BIN( it, end, src, from )
    while( it != end )
    {
        ur_setBit( bits, *it );
        ++it;
    }
}


static void _setBitsetStr( UThread* ut, uint8_t* bits, const UCell* from )
{
    char* it;
    char* end;
    UBinary* src = ur_bin(from);

    UR_ITER_STR( it, end, src, from )
    while( it != end )
    {
        //if( *it < 256 )
        {
            ur_setBit( bits, *it );
        }
        ++it;
    }
}


UIndex ur_makeBitset( UThread* ut, const UCell* from ) 
{
    UIndex binN;
    UBinary* bin;
    uint8_t* bits;
    int len;


    switch( ur_type(from) )
    {
        case UT_INT:
            len = (ur_int(from) + 7) / 8;
            break;

        case UT_BINARY:
            bin  = ur_bin(from);
            len  = bin->used;
            bits = bin->ptr.b;

            binN = ur_makeBinary( bin->used, &bin );
            bin->used = len;
            memCpy( bin->ptr.b, bits, len );
            return binN;

        default:
            len = 32;
            break;
    }

    binN = ur_makeBinary( len, &bin );
    bin->used = len;
    bits = bin->ptr.b;

    memSet( bits, 0, bin->used );

    switch( ur_type(from) )
    {
        case UT_CHAR:
            ur_setBit( bits, ur_char(from) );
            break;

        case UT_BLOCK:
        {
            UCell* it;
            UCell* end;
            UBlock* src = ur_block(from);
            int range = -1;

            UR_ITER_BLOCK( it, end, src, from )
            while( it != end )
            {
                switch( ur_type(it) )
                {
                    case UT_WORD:
                        if( (ur_atom(it) == UR_ATOM_DASH) &&
                            (range > -1) )
                        {
                            int r2;
                            UCell* rend = it + 1;
                            if( (rend != end) && ur_is(rend, UT_CHAR) )
                            {
                                r2 = ur_char(rend);
                                while( range < r2 )
                                {
                                    ++range;
                                    ur_setBit( bits, range );
                                }
                            }
                            range = -1;
                        }
                        break;

                    case UT_CHAR:
                        ur_setBit( bits, ur_char(it) );
                        range = ur_char(it);
                        break;

                    case UT_BINARY:
                        _setBitsetBin( ut, bits, it );
                        break;

                    case UT_STRING:
                        _setBitsetStr( ut, bits, it );
                        break;
                }
                ++it;
            }
        }
            break;

        case UT_STRING:
            _setBitsetStr( ut, bits, from );
            break;
    }

    return binN;
}


/*--------------------------------------------------------------------------*/


#define UR_MAX_PATH_LEN     16      // LIMIT: Maximum path/typemask nodes.


#define SET_PATH_NODE \
    if( count == (UR_MAX_PATH_LEN - 1) ) \
        return 0; \
    if( (*cp >= '0' && *cp <= '9') || (*cp == '-') ) { \
        node[ count ] = ur_stringToInt( cp, it, 0 ); \
    } else { \
        nodeType |= 1 << count; \
        node[ count ] = ur_intern( cp, it - cp ); \
    } \
    ++count;


/*
   Returns zero if spA is not a valid selector, datatype, or path.
*/
int ur_makeSelector( UThread* ut, UCell* res,
                     const char* spA, const char* end )
{
    const char* cp;
    co