Changeset 26

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.

Location:

trunk/orca

Files:

• bytecode.c (modified) (1 diff)
• context.c (modified) (4 diffs)
• gc.c (modified) (2 diffs)
• internal.h (modified) (1 diff)
• ovalue.c (modified) (10 diffs)
• ovalue.h (modified) (2 diffs)
• print.c (modified) (6 diffs)

trunk/orca/bytecode.c

@@ -55 +55 @@
         case OT_REFINEMENT:
         {
-            int len;
+            int pos;
             int atom;
-            OString* str;
 
             atom = (val->type == OT_REFINEMENT) ? val->index : val->word.atom;
-
-            str = orAtomString( atom );
-
-            // LIMIT: Assuming word names are never more than 255 characters.
-
-            len = str->used + 2;
-            RESERVE( len );
+            pos = bin->used;
+
+            orArrayReserve( bin, 1, bin->used + 2 );
+            bin->used += 2;
+
+            orAtomStr( atom, bin );
+
+            // LIMIT: Word names can never be more than 255 characters.
+            cp = bin->byteArray + pos;
             *cp++ = val->type;
-            *cp++ = str->used;
-
-            memCpy( cp, str->charArray, str->used );
+            *cp   = bin->used - pos - 2;
         }
             break;

trunk/orca/context.c

@@ -25 +25 @@
 
 
-OIndex orInternAtom( const char* str, int len )
+typedef struct
+{
+    uint16_t nameIndex;     // Index into BIN_ATOM_NAMES ptr.c
+    uint16_t nameLen;
+}
+AtomRec;
+
+
+/**
+  Appends atom name to string.
+*/
+void orAtomStr( OAtom atom, OString* str )
+{
+    OBinary* names;
+    AtomRec* rec;
+
+    rec = ((AtomRec*) orEnv->atoms.buf) + atom;
+    names = orStringPtr( BIN_ATOM_NAMES );
+
+    orArrayReserve( str, sizeof(char), str->used + rec->nameLen );
+    memCpy( str->charArray + str->used,
+            names->charArray + rec->nameIndex,
+            rec->nameLen );
+    str->used += rec->nameLen;
+}
+
+
+const char* orAtomCString( OAtom atom )
+{
+    static char buf[ MAX_WORD_LEN + 1 ];
+    OBinary* names;
+    AtomRec* rec;
+
+    rec = ((AtomRec*) orEnv->atoms.buf) + atom;
+    names = orStringPtr( BIN_ATOM_NAMES );
+
+    memCpy( buf, names->charArray + rec->nameIndex, rec->nameLen );
+    buf[ rec->nameLen ] = '\0';
+    return buf;
+}
+
+
+/**
+  Add atom to environment.
+
+  \param str  Name of atom.
+  \param len  Number of characters.  Str will be truncated if greater than 32.
+
+  \returns Atom
+*/
+OAtom orInternAtom( const char* str, int len )
 {
     char* cp;
     const char* ep;
     const char* sp;
-    OString* cstr;
     OArray* atoms;
-    OIndex* it;
-    OIndex* end;
+    OString* names;
+    AtomRec* rec;
+    AtomRec* end;
+    char buf[ MAX_WORD_LEN ];
 
 
     assert( len > 0 );
-    assert( (unsigned int) len < sizeof(orTmp) );
-
-    // Make lowercase and find end of string.
-
-    cp = orTmp;
-    ep = cp + len;
+
+    if( len > MAX_WORD_LEN )
+        len = MAX_WORD_LEN;
+
+    // Make lowercase.
+
+    cp = buf;
+    ep = buf + len;
     while( cp != ep )
     {
@@ -51 +104 @@
     }
 
-
     // Check if atom already exists.
 
     atoms = &orEnv->atoms;
-    it  = atoms->indices;
-    end = it + atoms->used;
-
-    while( it != end )
-    {
-        cstr = orSTRINGS + *it;
-        if( cstr->used == len )
-        {
-            sp = cstr->charArray;
-            cp = orTmp;
+    rec = (AtomRec*) atoms->buf;
+    end = rec + atoms->used;
+
+    names = orStringPtr( BIN_ATOM_NAMES );
+
+    while( rec != end )
+    {
+        if( rec->nameLen == len )
+        {
+            sp = names->charArray + rec->nameIndex;
+            cp = buf;
             while( cp != ep )
             {
@@ -73 +126 @@
 
             if( cp == ep )
-                return it - atoms->indices;
-        }
-        ++it;
+                goto done;
+        }
+        ++rec;
     }
 
@@ -81 +134 @@
     // Nope, add new atom.
 
-    // Must increment atoms->used after orMakeCString() in case garbage
-    // collection occurs (*it will be uninitialized).
-    //OA_EXPAND1( OIndex, atoms, it );
-    orArrayReserve(atoms, sizeof(OIndex), atoms->used+1);
-    it = atoms->indices + atoms->used;
-    *it = orMakeCString( orTmp, len );
-    ++atoms->used;
-    return it - atoms->indices;
+    OA_EXPAND1( AtomRec, atoms, rec );
+    rec->nameIndex = names->used;
+    rec->nameLen   = len;
+
+    orArrayReserve( names, sizeof(char), names->used + len );
+    memCpy( names->charArray + names->used, buf, len );
+    names->used += len;
+
+done:
+
+    return rec - ((AtomRec*) atoms->buf);
 }
 

trunk/orca/gc.c

@@ -518 +518 @@
     assert( orEnv->error == 0 );
 
+
+    // Enable this if orLockGarbageCollector() is removed.
+    //orSetBit( bsStr.byteArray, BIN_ATOM_NAMES );
+
     blk = (OBlock*) orEnv->blocks.buf;
 
@@ -581 +585 @@
 
 
-    {
-    // Mark strings used by atoms.
-    int idx;
-    OIndex* it  = orEnv->atoms.indices + orEnv->sweepStartAtom;
-    OIndex* end = orEnv->atoms.indices + orEnv->atoms.used;
-    while( it != end )
-    {
-        idx = *it - orEnv->freeStrings.sweepStart;
-        if( idx >= 0 )
-            orSetBit( bsStr.byteArray, idx );
-        ++it;
-    }
-    }
-
     orSweepArray( &bsBlk, &orEnv->freeBlocks,  &orEnv->blocks );
     orSweepArray( &bsStr, &orEnv->freeStrings, &orEnv->strings );

trunk/orca/internal.h

@@ -2 +2 @@
 #define INTERNAL_H
 
+
+#define MAX_WORD_LEN        32      /* LIMIT: word length */
+
+#define BIN_ATOM_NAMES      0
 
 #define GLOBAL_CTXN         0

trunk/orca/ovalue.c

@@ -101 +101 @@
 
 extern OBlock* orTokenize( const char*, const char* );
+extern const char* orAtomCString( OAtom );
 
 extern void orBindNative( OValue* );
@@ -336 +337 @@
     orInitAGC( &env->freeIntArr );
 #endif
+
+    orMakeString( 2048 );     // BIN_ATOM_NAMES
 
     makeGlobalContext();
@@ -1366 +1369 @@
         if( val->type == OT_UNSET )
         {
-            OString* str = orAtomString( a1->word.atom );
-            orError( "%s has no value", str->charArray );
+            orError( "%s has no value", orAtomCString( a1->word.atom ) );
         }
         else
@@ -1996 +1998 @@
 
 unset:
-    {
-    OString* str;
-    str = orAtomString( pit->word.atom );
-    orError( "Path word %s has no value", str->charArray );
-    }
+    orError( "Path word %s has no value", orAtomCString( pit->word.atom ) );
     return -1;
 
@@ -2220 +2218 @@
             {
                 case OT_UNSET:
-                    {
-                    OString* str = orAtomString( pc->word.atom );
-                    orError( "%s has no value", str->charArray );
-                    }
+                    orError( "%s has no value", orAtomCString(pc->word.atom) );
                     return -1;
 
@@ -2317 +2312 @@
                 if( wblk->values[ pc->word.index ].flags & OR_WORD_PROT )
                 {
-                    OString* str = orAtomString( pc->word.atom );
-                    orError( "Word %s is protected", str->charArray );
+                    orError( "Word %s is protected", 
+                             orAtomCString( pc->word.atom ) );
                     goto sThrown;
                 }
             }
 #ifdef TRACE
-            cprint( "TR> %s:\n", orAtomString(pc->word.atom)->charArray );
+            cprint( "TR> %s:\n", orAtomCString( pc->word.atom ) );
 #endif
             PUSH_CALL( wval, OC_SETWORD, 0 );
@@ -2768 +2763 @@
     if( si == send )
     {
-        OString* str = orAtomString( pp->word.atom );
-        orError( "Function has no refinement %s", str->charArray ); 
+        orError( "Function has no refinement %s", 
+                 orAtomCString( pp->word.atom ) );
         goto sThrown;
     }
@@ -3093 +3088 @@
                 (it->type == OT_LITWORD) )
             {
-                OString* str = orAtomString( it->word.atom );
                 dprint( " %d %d %s\n", it->word.context, it->word.index,
-                        str->charArray );
+                        orAtomCString( it->word.atom ) );
             }
             else if( it->type == OT_DATATYPE )
@@ -3938 +3932 @@
             orDatatypeName(type),
             (orSTRINGS + wrd->str)->charArray,
-            orAtomString(wrd->atom)->charArray,
+            orAtomCString( wrd->atom ),
             val->word.atom );
 #endif
@@ -4286 +4280 @@
         {
 #if 0
-            OString* str = orAtomString( it->word.atom );
-            dprint( "orFuncNative - intern %s\n", str->charArray );
+            dprint( "orFuncNative - intern %s\n",
+                    orAtomCString( it->word.atom ) );
 #endif
             prevWord = 1;

trunk/orca/ovalue.h

@@ -384 +384 @@
 void    orInitEnv( OEnv*, int dataStackSize, int callStackSize );
 void    orFreeEnv( OEnv* );
-OIndex  orInternAtom( const char* str, int len );
+void    orAtomStr( OAtom, OString* );
+OAtom   orInternAtom( const char* str, int len );
 OIndex  orInternA( OBlock* wordBlk, OAtom );
 OValue* orIntern( OContext*, const char* str, int len, OValue* wordV );
@@ -506 +507 @@
     val = blk->values + wv->word.index
 
-#define orAtomString(atom)      (orSTRINGS + orEnv->atoms.indices[atom])
-
 #define orMakePath(n)           orMakeBlock(n)
 #define orMakeBinary(n)         ((OBinary*) orMakeString(n))

trunk/orca/print.c

@@ -374 +374 @@
     OValue* it;
     OValue* end;
-    OString* str;
 
     wblk = orBlockPtr( ctx->wblkN );
@@ -392 +391 @@
     while( it != end )
     {
-        str = orAtomString( wval->word.atom );
-
         indent( out, depth );
-        append( out, str->charArray, str->used );
+
+        orAtomStr( wval->word.atom, out );
         append( out, ": ", 2 );
 
@@ -519 +517 @@
                             break;
 
-        case OT_REFINEMENT: {
-                            OString* str = orAtomString( val->index );
-                            append(out, str->charArray, str->used);
-                            }
+        case OT_REFINEMENT: orAtomStr( val->index, out );
                             break;
 
         case OT_WORD:
         case OT_LITWORD:
-        case OT_SETWORD:
-        case OT_GETWORD:    {
-                            OString* str = orAtomString( val->word.atom );
-                            append(out, str->charArray, str->used);
-                            }
+        case OT_SETWORD:    orAtomStr( val->word.atom, out );
                             break;
 
@@ -703 +694 @@
                             break;
 
-        case OT_REFINEMENT: {
-                            OString* str = orAtomString( val->index );
-                            append1('/', out);
-                            append(out, str->charArray, str->used);
-                            }
-                            break;
-
-        case OT_WORD:       {
-                            OString* str = orAtomString( val->word.atom );
-                            append(out, str->charArray, str->used);
-                            }
-                            break;
-
-        case OT_LITWORD:    {
-                            OString* str = orAtomString( val->word.atom );
-                            append1(39, out);
-                            append(out, str->charArray, str->used);
-                            }
-                            break;
-
-        case OT_SETWORD:    {
-                            OString* str = orAtomString( val->word.atom );
-                            append(out, str->charArray, str->used);
+        case OT_REFINEMENT: append1('/', out);
+                            orAtomStr( val->index, out );
+                            break;
+
+        case OT_LITWORD:    append1('\'', out);
+                            // fall through to OT_WORD
+
+        case OT_WORD:       orAtomStr( val->word.atom, out );
+                            break;
+
+        case OT_SETWORD:    orAtomStr( val->word.atom, out );
                             append1(':', out);
-                            }
-                            break;
-
-        case OT_GETWORD:    {
-                            OString* str = orAtomString( val->word.atom );
-                            append1(':', out);
-                            append(out, str->charArray, str->used);
-                            }
+                            break;
+
+        case OT_GETWORD:    append1(':', out);
+                            orAtomStr( val->word.atom, out );
                             break;
 
@@ -1048 +1023 @@
             OValue* end = it + wblk->used;
             OValue* vit = vblk->values;
-            OString* str;
 
             ((OValue*) val)->flags |= OR_FLAG_RECURSION;
@@ -1067 +1041 @@
                     indent(out, depth + 1);
 
-                    str = orAtomString( it->word.atom );
-                    append( out, str->charArray, str->used );
+                    orAtomStr( it->word.atom, out );
                     append( out, ": ", 2 );
                     mold( out, vit, depth + 1 );