Changeset 25 for trunk/orca/series.c

Timestamp:

02/06/06 23:30:15 (3 years ago)

Author:

krobillard

Message:

series which/index renamed to n/it.

Files:

• trunk/orca/series.c (modified) (82 diffs)

trunk/orca/series.c

@@ -119 +119 @@
     {
         len = 0;
-        if( a1->series.index )
+        if( a1->series.it )
         {
             OBlock* blk = orBLOCK(a1);
-            OValue* it = blk->values + a1->series.index;
+            OValue* it = blk->values + a1->series.it;
             while( it->LIST_NEXT > 0 )
             {
@@ -134 +134 @@
         len = orSeriesUsed(a1);
         if( len > -1 )
-            len -= a1->series.index;
+            len -= a1->series.it;
     }
 
@@ -147 +147 @@
     {
         OBlock* blk = orBLOCK(a1);
-        a1->series.index = blk->values->LIST_NEXT;
+        a1->series.it = blk->values->LIST_NEXT;
     }
     else if( orIsSeries(a1->type) )
-        a1->series.index = 0;
+        a1->series.it = 0;
     else
         orError( "head expected series argument" );
@@ -160 +160 @@
     if( a1->type == OT_LIST )
     {
-        a1->series.index = LIST_TAIL;
+        a1->series.it = LIST_TAIL;
     }
     else
@@ -166 +166 @@
         int len = orSeriesUsed(a1);
         if( len > -1 )
-            a1->series.index = len;
+            a1->series.it = len;
         else
             orError( "tail expected series argument" );
@@ -178 +178 @@
     {
         OBlock* blk = orBLOCK(a1);
-        OValue* it = blk->values + a1->series.index;
+        OValue* it = blk->values + a1->series.it;
         if( it->LIST_PREV > 0 )
-            a1->series.index = it->LIST_PREV;
+            a1->series.it = it->LIST_PREV;
     }
     else if( orIsSeries(a1->type) )
     {
-        if( a1->series.index > 0 )
-            --a1->series.index;
+        if( a1->series.it > 0 )
+            --a1->series.it;
     }
     else
@@ -198 +198 @@
     if( a1->type == OT_LIST )
     {
-        if( a1->series.index )
+        if( a1->series.it )
         {
             OBlock* blk = orBLOCK(a1);
-            OValue* it = blk->values + a1->series.index;
+            OValue* it = blk->values + a1->series.it;
             if( it->LIST_NEXT > 0 )
-                a1->series.index = it->LIST_NEXT;
+                a1->series.it = it->LIST_NEXT;
         }
     }
@@ -209 +209 @@
     {
         int len = orSeriesUsed(a1);
-        if( a1->series.index < len )
-            ++a1->series.index;
+        if( a1->series.it < len )
+            ++a1->series.it;
     }
 }
@@ -223 +223 @@
     else if( orIsSeries(a1->type) )
     {
-        orResult( OT_INTEGER, a1->series.index + 1 );
+        orResult( OT_INTEGER, a1->series.it + 1 );
         return;
     }
@@ -237 +237 @@
     {
         OBlock* blk = orBLOCK(a1);
-        OValue* it = blk->values + a1->series.index;
+        OValue* it = blk->values + a1->series.it;
         if( it->LIST_PREV == LIST_HEAD )
             logic = OR_TRUE;
@@ -243 +243 @@
     else
     {
-        if( a1->series.index == 0 )
+        if( a1->series.it == 0 )
             logic = OR_TRUE;
     }
@@ -257 +257 @@
     if( a1->type == OT_LIST )
     {
-        if( a1->series.index == LIST_TAIL )
+        if( a1->series.it == LIST_TAIL )
            logic = OR_TRUE;
     }
@@ -265 +265 @@
         if( len > -1)
         {
-            if( a1->series.index >= len )
+            if( a1->series.it >= len )
                logic = OR_TRUE;
         }
@@ -283 +283 @@
         {
             OBlock* blk = orBLOCK(a1);
-            if( a1->series.index < blk->used )
-                blk->used = a1->series.index;
+            if( a1->series.it < blk->used )
+                blk->used = a1->series.it;
         }
             break;
@@ -295 +295 @@
         {
             OString* str = orSTRING(a1);
-            if( a1->series.index < str->used )
-                str->used = a1->series.index;
+            if( a1->series.it < str->used )
+                str->used = a1->series.it;
         }
             break;
@@ -316 +316 @@
         {
             OArray* arr = orDEC_ARRAY(a1);
-            if( a1->series.index < arr->used )
-                arr->used = a1->series.index;
+            if( a1->series.it < arr->used )
+                arr->used = a1->series.it;
         }
             break;
@@ -324 +324 @@
         {
             OArray* arr = orINT_ARRAY(a1);
-            if( a1->series.index < arr->used )
-                arr->used = a1->series.index;
+            if( a1->series.it < arr->used )
+                arr->used = a1->series.it;
         }
             break;
@@ -392 +392 @@
         ipos = orStrChars( s1, a1 );
 
-        if( a1->series.index < used )
+        if( a1->series.it < used )
         {
             copyReverseC( s1->charArray + used - 1, ipos - 1,
@@ -401 +401 @@
 
         s1->used += len;
-        a1->series.index += len;
+        a1->series.it += len;
     }
 }
@@ -431 +431 @@
 
                 // Must get ipos after orArrayReserve.
-                ipos = s1->values + a1->series.index;
+                ipos = s1->values + a1->series.it;
 
                 copyReverseV( s1->values + used - 1, ipos - 1,
                               s1->values + used );
                 ++s1->used;
-                ++a1->series.index;
+                ++a1->series.it;
                 *ipos = *a2;
             }
@@ -445 +445 @@
                 OBlock* s2 = orBLOCK(a2);
                 int used = s1->used;
-                int srcLen = s2->used - a2->series.index;
+                int srcLen = s2->used - a2->series.it;
 
                 orArrayReserve( s1, sizeof(OValue), used + srcLen );
 
                 // Must get ipos after orArrayReserve.
-                ipos = s1->values + a1->series.index;
-
-                if( a1->series.index < used )
+                ipos = s1->values + a1->series.it;
+
+                if( a1->series.it < used )
                 {
                     copyReverseV( s1->values + used - 1, ipos - 1,
@@ -458 +458 @@
                 }
 
-                copyV( s2->values + a2->series.index,
+                copyV( s2->values + a2->series.it,
                        s2->values + s2->used,
                        ipos );
 
                 s1->used += srcLen;
-                a1->series.index += srcLen;
+                a1->series.it += srcLen;
             }
             break;
@@ -479 +479 @@
                 {
                     OString* tmp;
-                    OValue* it  = blk->values + a2->series.index;
+                    OValue* it  = blk->values + a2->series.it;
                     OValue* end = blk->values + blk->used;
 
-                    assert( a2->series.index <= blk->used );
+                    assert( a2->series.it <= blk->used );
 
                     orRefPush( OT_BLOCK, a2->index );
@@ -507 +507 @@
             {
                 OString* s2 = orSTRING(a2);
-                stringInsert( a1, s2->charArray + a2->series.index,
-                                  s2->used - a2->series.index );
+                stringInsert( a1, s2->charArray + a2->series.it,
+                                  s2->used - a2->series.it );
             }
             else if( a2->type == OT_CHAR )
@@ -523 +523 @@
 
         case OT_LIST:
-            if( a1->series.index )
+            if( a1->series.it )
             {
                 OBlock* lst = orBLOCK( a1 );
-                OValue* node = lst->values + a1->series.index;
+                OValue* node = lst->values + a1->series.it;
 
                 if( node->LIST_PREV < 0 )
@@ -533 +533 @@
                 if( (a2->type != OT_BLOCK) || orRefineSet(REF_INS_ONLY) )
                 {
-                    orListInsertValue( lst, a1->series.index, a2 );
+                    orListInsertValue( lst, a1->series.it, a2 );
                 }
                 else
                 {
                     OBlock* blk = orBLOCK( a2 );
-                    OValue* it  = blk->values + a2->series.index;
+                    OValue* it  = blk->values + a2->series.it;
                     OValue* end = blk->values + blk->used;
 
                     while( it != end )
                     {
-                        orListInsertValue( lst, a1->series.index, it );
+                        orListInsertValue( lst, a1->series.it, it );
                         ++it;
                     }
@@ -595 +595 @@
         {
             OBlock* arr = orBLOCK(a1);
-            orArrayErase( arr, sizeof(OValue), a1->series.index, len );
+            orArrayErase( arr, sizeof(OValue), a1->series.it, len );
         }
             break;
@@ -606 +606 @@
         {
             OString* arr = orSTRING(a1);
-            orArrayErase( arr, sizeof(char), a1->series.index, len );
+            orArrayErase( arr, sizeof(char), a1->series.it, len );
         }
             break;
@@ -614 +614 @@
         {
             OArray* arr = orDEC_ARRAY(a1);
-            orArrayErase( arr, sizeof(double), a1->series.index, len );
+            orArrayErase( arr, sizeof(double), a1->series.it, len );
         }
             break;
@@ -621 +621 @@
         {
             OArray* arr = orINT_ARRAY(a1);
-            orArrayErase( arr, sizeof(int32_t), a1->series.index, len );
+            orArrayErase( arr, sizeof(int32_t), a1->series.it, len );
         }
             break;
@@ -631 +631 @@
             OValue* it;
             OBlock* blk = orBLOCK(a1);
-            OValue* node = blk->values + a1->series.index;
+            OValue* node = blk->values + a1->series.it;
 
             if( node->LIST_LINKED )
@@ -648 +648 @@
 
                 node->LIST_FREE = blk->values->LIST_FREE;
-                blk->values->LIST_FREE = a1->series.index;
+                blk->values->LIST_FREE = a1->series.it;
 
                 /*
@@ -660 +660 @@
 
                 // Result.
-                a1->series.index = nextI;
+                a1->series.it = nextI;
             }
             else
@@ -691 +691 @@
         {
             OBlock* blk = orBLOCK( ser );
-            n += ser->series.index;
+            n += ser->series.it;
             if( (n > -1) && (n < blk->used) )
             {
@@ -706 +706 @@
         {
             OString* str = orSTRING( ser );
-            n += ser->series.index;
+            n += ser->series.it;
             if( (n > -1) && (n < str->used) )
             {
@@ -719 +719 @@
         {
             OBinary* str = orSTRING( ser );
-            n += ser->series.index;
+            n += ser->series.it;
             if( (n > -1) && (n < str->used) )
             {
@@ -748 +748 @@
 
         case OT_LIST:
-            if( ser->series.index )
+            if( ser->series.it )
             {
                 OBlock* blk = orBLOCK( ser );
-                OValue* it = blk->values + ser->series.index;
+                OValue* it = blk->values + ser->series.it;
 
                 while( it->LIST_NEXT > 0 )
@@ -793 +793 @@
         {
             OArray* arr = orDEC_ARRAY( ser );
-            n += ser->series.index;
+            n += ser->series.it;
             if( (n > -1) && (n < arr->used) )
             {
@@ -806 +806 @@
         {
             OArray* arr = orINT_ARRAY( ser );
-            n += ser->series.index;
+            n += ser->series.it;
             if( (n > -1) && (n < arr->used) )
             {
@@ -860 +860 @@
         {
             OBlock* blk = orBLOCK(a1);
-            if( (blk->used - a1->series.index) < 1 )
+            if( (blk->used - a1->series.it) < 1 )
                 break;
             orCopyV( result, blk->values[ blk->used - 1 ] );
@@ -873 +873 @@
         {
             OString* str = orSTRING(a1);
-            if( (str->used - a1->series.index) < 1 )
+            if( (str->used - a1->series.it) < 1 )
                 break;
             orSetTF( result, OT_CHAR );
@@ -905 +905 @@
         {
             OArray* arr = orDEC_ARRAY(a1);
-            if( (arr->used - a1->series.index) < 1 )
+            if( (arr->used - a1->series.it) < 1 )
                 break;
             orSetTF( result, OT_DECIMAL );
@@ -915 +915 @@
         {
             OArray* arr = orINT_ARRAY(a1);
-            if( (arr->used - a1->series.index) < 1 )
+            if( (arr->used - a1->series.it) < 1 )
                 break;
             orSetTF( result, OT_INTEGER );
@@ -966 +966 @@
             range = rval->integer;
         else
-            range = rval->series.index;
+            range = rval->series.it;
 
         if( range > used )
@@ -976 +976 @@
     }
 
-    if( (range < 1) || (range < a1->series.index) )
+    if( (range < 1) || (range < a1->series.it) )
     {
         orError( "Invalid range %d", range );
@@ -998 +998 @@
             if( range )
             {
-                reverseV( blk->values + a1->series.index,
+                reverseV( blk->values + a1->series.it,
                           blk->values + range );
-                a1->series.index = range;
+                a1->series.it = range;
             }
         }
@@ -1016 +1016 @@
             if( range )
             {
-                reverseC( str->charArray + a1->series.index,
+                reverseC( str->charArray + a1->series.it,
                           str->charArray + range );
-                a1->series.index = range;
+                a1->series.it = range;
             }
         }
@@ -1054 +1054 @@
         if( n )
         {
-            n += a1->series.index;
+            n += a1->series.it;
             if( n < 0 )
                 n = 0;
             else if( n > len )
                 n = len;
-            a1->series.index = n;
+            a1->series.it = n;
         }
         return;
@@ -1089 +1089 @@
     used = orSeriesUsed( a1 );
 
-    n += a1->series.index;
+    n += a1->series.it;
     if( n < 0 )
         n = 0;
     else if( n > used )
         n = used;
-    a1->series.index = n;
+    a1->series.it = n;
 }
 
@@ -1150 +1150 @@
         n = a2->integer ? 0 : 1;
 
-    n += a1->series.index;
+    n += a1->series.it;
     if( n < 0 )
         goto bad_index;
@@ -1249 +1249 @@
 
             blk = orBLOCK(a1);
-            it  = blk->values + a1->series.index;
+            it  = blk->values + a1->series.it;
             end = blk->values + blk->used;
             while( it != end )
@@ -1282 +1282 @@
 
             str = orSTRING(a1);
-            it  = str->charArray + a1->series.index;
+            it  = str->charArray + a1->series.it;
             end = str->charArray + str->used;
             while( it != end )
@@ -1316 +1316 @@
     int len;
 
-    orig = ((OArray*) storage->buf) + val->series.which;
-    data = orig->charArray + (val->series.index * elemSize);
-    len  = orig->used - val->series.index;
+    orig = ((OArray*) storage->buf) + val->series.n;
+    data = orig->charArray + (val->series.it * elemSize);
+    len  = orig->used - val->series.it;
 
     if( len > part )
@@ -1332 +1332 @@
     }
 
-    val->series.which = copyN;
-    val->series.index = 0;
+    val->series.n  = copyN;
+    val->series.it = 0;
 }
 
@@ -1360 +1360 @@
 
             orig = orBLOCK(val);
-            it   = orig->values + val->series.index;
-            len  = orig->used - val->series.index;
+            it   = orig->values + val->series.it;
+            len  = orig->used - val->series.it;
 
             if( len > part )
@@ -1393 +1393 @@
 
             val->index = blkN;
-            val->series.index = 0;
+            val->series.it = 0;
         }
             break;
@@ -1415 +1415 @@
 
             orig = orSTRING(val);
-            it   = orig->charArray + val->series.index;
-            len  = orig->used - val->series.index;
+            it   = orig->charArray + val->series.it;
+            len  = orig->used - val->series.it;
 
             if( len > part )
@@ -1431 +1431 @@
 
             val->index = strN;
-            val->series.index = 0;
+            val->series.it = 0;
         }
 #endif
@@ -1467 +1467 @@
     if( (a1->type == OT_BITSET) || (a1->type == OT_MATRIX) )
     {
-        OString* arr = orCopyString( a1->index, a1->series.index );
+        OString* arr = orCopyString( a1->index, a1->series.it );
         orSetSeries( a1, orStringN(arr), 0 );
     }
@@ -1480 +1480 @@
                 part = rng->integer;
             else if( orIsSeries(rng->type) && orIsSeries(a1->type) )
-                part = rng->series.index - a1->series.index;
+                part = rng->series.it - a1->series.it;
             else
                 part = 0x7fffffff;
@@ -1524 +1524 @@
                 assert( a1->index != a2->index );
 
-                assert( a1->series.index <= s1->used );
-                assert( a2->series.index <= s2->used );
-
-                len2 = s2->used - a2->series.index;
+                assert( a1->series.it <= s1->used );
+                assert( a2->series.it <= s2->used );
+
+                len2 = s2->used - a2->series.it;
                 if( len2 > 0 )
                 {