Changeset 26 for trunk/orca/context.c

Show
Ignore:
Timestamp:
02/07/06 00:52:42 (3 years ago)
Author:
krobillard
Message:

Atom names are now stored in a single string.
Maximum word length is now 32.

Files:
1 modified

Legend:

Unmodified
Added
Removed

  • trunk/orca/context.c

    r25 r26  
    2525 
    2626 
    27 OIndex orInternAtom( const char* str, int len ) 
     27typedef struct 
     28{ 
     29    uint16_t nameIndex;     // Index into BIN_ATOM_NAMES ptr.c 
     30    uint16_t nameLen; 
     31} 
     32AtomRec; 
     33 
     34 
     35/** 
     36  Appends atom name to string. 
     37*/ 
     38void orAtomStr( OAtom atom, OString* str ) 
     39{ 
     40    OBinary* names; 
     41    AtomRec* rec; 
     42 
     43    rec = ((AtomRec*) orEnv->atoms.buf) + atom; 
     44    names = orStringPtr( BIN_ATOM_NAMES ); 
     45 
     46    orArrayReserve( str, sizeof(char), str->used + rec->nameLen ); 
     47    memCpy( str->charArray + str->used, 
     48            names->charArray + rec->nameIndex, 
     49            rec->nameLen ); 
     50    str->used += rec->nameLen; 
     51} 
     52 
     53 
     54const char* orAtomCString( OAtom atom ) 
     55{ 
     56    static char buf[ MAX_WORD_LEN + 1 ]; 
     57    OBinary* names; 
     58    AtomRec* rec; 
     59 
     60    rec = ((AtomRec*) orEnv->atoms.buf) + atom; 
     61    names = orStringPtr( BIN_ATOM_NAMES ); 
     62 
     63    memCpy( buf, names->charArray + rec->nameIndex, rec->nameLen ); 
     64    buf[ rec->nameLen ] = '\0'; 
     65    return buf; 
     66} 
     67 
     68 
     69/** 
     70  Add atom to environment. 
     71 
     72  \param str  Name of atom. 
     73  \param len  Number of characters.  Str will be truncated if greater than 32. 
     74 
     75  \returns Atom 
     76*/ 
     77OAtom orInternAtom( const char* str, int len ) 
    2878{ 
    2979    char* cp; 
    3080    const char* ep; 
    3181    const char* sp; 
    32     OString* cstr; 
    3382    OArray* atoms; 
    34     OIndex* it; 
    35     OIndex* end; 
     83    OString* names; 
     84    AtomRec* rec; 
     85    AtomRec* end; 
     86    char buf[ MAX_WORD_LEN ]; 
    3687 
    3788 
    3889    assert( len > 0 ); 
    39     assert( (unsigned int) len < sizeof(orTmp) ); 
    40  
    41     // Make lowercase and find end of string. 
    42  
    43     cp = orTmp; 
    44     ep = cp + len; 
     90 
     91    if( len > MAX_WORD_LEN ) 
     92        len = MAX_WORD_LEN; 
     93 
     94    // Make lowercase. 
     95 
     96    cp = buf; 
     97    ep = buf + len; 
    4598    while( cp != ep ) 
    4699    { 
    … …  
    51104    } 
    52105 
    53  
    54106    // Check if atom already exists. 
    55107 
    56108    atoms = &orEnv->atoms; 
    57     it  = atoms->indices; 
    58     end = it + atoms->used; 
    59  
    60     while( it != end ) 
    61     { 
    62         cstr = orSTRINGS + *it; 
    63         if( cstr->used == len ) 
    64         { 
    65             sp = cstr->charArray; 
    66             cp = orTmp; 
     109    rec = (AtomRec*) atoms->buf; 
     110    end = rec + atoms->used; 
     111 
     112    names = orStringPtr( BIN_ATOM_NAMES ); 
     113 
     114    while( rec != end ) 
     115    { 
     116        if( rec->nameLen == len ) 
     117        { 
     118            sp = names->charArray + rec->nameIndex; 
     119            cp = buf; 
    67120            while( cp != ep ) 
    68121            { 
    … …  
    73126 
    74127            if( cp == ep ) 
    75                 return it - atoms->indices; 
    76         } 
    77         ++it; 
     128                goto done; 
     129        } 
     130        ++rec; 
    78131    } 
    79132 
    … …  
    81134    // Nope, add new atom. 
    82135 
    83     // Must increment atoms->used after orMakeCString() in case garbage 
    84     // collection occurs (*it will be uninitialized). 
    85     //OA_EXPAND1( OIndex, atoms, it ); 
    86     orArrayReserve(atoms, sizeof(OIndex), atoms->used+1); 
    87     it = atoms->indices + atoms->used; 
    88     *it = orMakeCString( orTmp, len ); 
    89     ++atoms->used; 
    90     return it - atoms->indices; 
     136    OA_EXPAND1( AtomRec, atoms, rec ); 
     137    rec->nameIndex = names->used; 
     138    rec->nameLen   = len; 
     139 
     140    orArrayReserve( names, sizeof(char), names->used + len ); 
     141    memCpy( names->charArray + names->used, buf, len ); 
     142    names->used += len; 
     143 
     144done: 
     145 
     146    return rec - ((AtomRec*) atoms->buf); 
    91147} 
    92148