Changeset 31

Timestamp:

02/08/06 01:35:49 (3 years ago)

Author:

krobillard

Message:

Overflow of the quick hold stack is now caught.

Location:

trunk/orca

Files:

• TODO (modified) (1 diff)
• console.c (modified) (1 diff)
• context.c (modified) (6 diffs)
• gc.c (modified) (1 diff)
• ovalue.c (modified) (7 diffs)
• ovalue.h (modified) (3 diffs)
• tokenize.c (modified) (3 diffs)

trunk/orca/TODO

@@ -25 +25 @@
 Thune Backport
 
-  * Words are stored in single string.
   * UCell union
   * Value structure hidden more using macros (ur_int(), etc.)

trunk/orca/console.c

@@ -89 +89 @@
     else
     {
-        printf( "ORCA-Core %s (%s)\n", VERSION_STR, __DATE__ );
+        printf( "ORCA %s (%s)\n", VERSION_STR, __DATE__ );
 halt:
         while( 1 )

trunk/orca/context.c

@@ -245 +245 @@
 {
     ctx->wblkN = orBlockN( orMakeBlock( size ) );
+
+    // Assuming caller checks orRefAvail.
     orRefPush( OT_BLOCK, ctx->wblkN );
     ctx->vblkN = orBlockN( orMakeBlock( size ) );
@@ -293 +295 @@
     int wcount;
 
+
+    if( ! orRefAvail( 4 ) )
+        return 0;
 
     wcount = 0;
@@ -424 +429 @@
 
 
+    if( ! orRefAvail( 3 ) )
+        return -1;
+
     orRefPush( OT_BLOCK, blkN );
 
@@ -740 +748 @@
 
 
+    orRefAvailErr( 2 )
     orRefPush( OT_BLOCK, a2->index );
 
@@ -810 +819 @@
     // Still, 'foreach is faster than 'forall (probably because using paths
     // is so slow).
+
+    orRefAvailErr( 4 )
 
     // Must hold body & a2 in case orMakeContext() or orCopyBlock() trigger
@@ -1036 +1047 @@
     OIndex bi   = (a1 + 2)->series.it;
     OValue saveA1;
+
+
+    orRefAvailErr( 2 )
 
     if( a1->type == OT_BLOCK )

trunk/orca/gc.c

@@ -530 +530 @@
     checkCallStack();
 
-    checkHolds( orEnv->quickHolds, orEnv->quickHoldsTop );
+    checkHolds( orEnv->quickHolds,
+                orEnv->quickHolds + orEnv->quickHoldsUsed );
 
     if( orEnv->holds.used )

trunk/orca/ovalue.c

@@ -304 +304 @@
     env->secure    = 0;
 
-    // TODO: Do something about quickHolds stack overflow. Just use orHold()?
-    env->quickHolds    = memAlloc( sizeof(OHold) * 256 );
-    env->quickHoldsTop = env->quickHolds;
+    env->quickHolds     = memAlloc( sizeof(OHold) * OR_MAX_QHOLDS );
+    env->quickHoldsUsed = 0;
 
     // NOTE: The data & call stacks are never resized so that it is safe
@@ -535 +534 @@
     env->callStack.used = 0;
     env->dataStack.used = 0;
-    env->quickHoldsTop = env->quickHolds;
+    env->quickHoldsUsed = 0;
     env->error = 0;      //orErrorClear;
 }
@@ -1340 +1339 @@
         OValue fileVal = *a1;
 
+        orRefAvailErr( 2 );
         orRefPush( OT_FILE, a1->index );
         // Need to ref args?
@@ -1648 +1648 @@
     OIndex bi   = (a1 + 1)->series.it;
 
+    orRefAvailErr( 2 )
     orRefPush( OT_BLOCK, cond );
     orRefPush( OT_BLOCK, body );
@@ -2887 +2888 @@
         int vi;
 
+        orRefAvailErr( 3 )
         orRefPush( OT_BLOCK, a1->index );
         rblk = orMakeBlock(0);
@@ -3053 +3055 @@
     int reti;
 
+    /* Check if 2 are free because there is an orRefPush in orEval()
+       and we can save a check there by doing it here.
+       This is the only check which will catch an endlessly recursive does.
+     */
+    orRefAvailErr( 2 )
     orRefPush( OT_BLOCK, blkN );
 
@@ -4239 +4246 @@
 
 
+    orRefAvailErr( 4 )
     orRefPush( OT_BLOCK, a1->index );
     orRefPush( OT_BLOCK, a2->index );

trunk/orca/ovalue.h

@@ -118 +118 @@
 
 #define OR_INVALID_HOLD -1
+#define OR_MAX_QHOLDS   256
 
 
@@ -358 +359 @@
 
     OHold*      quickHolds;
-    OHold*      quickHoldsTop;
+    int         quickHoldsUsed;
 
 #ifdef OR_CONFIG_NUMBER_ARRAYS
@@ -497 +498 @@
 #define orIsNumber(t)   ((t == OT_INTEGER) || (t == OT_DECIMAL))
 
+#define orRefAvail(n) \
+    (((OR_MAX_QHOLDS - 1) - orEnv->quickHoldsUsed) > n)
+
+#define orRefAvailErr(n) \
+    if( ! orRefAvail(n) ) { \
+        orErrorT(OR_ERROR_INTERNAL, "Hold stack overflow"); \
+        return; }
+
 #define orRefPush(type,index) \
-    orEnv->quickHoldsTop->dataType = type; \
-    orEnv->quickHoldsTop->which = index; \
-    ++orEnv->quickHoldsTop
-
-#define orRefPop(count)         orEnv->quickHoldsTop -= count
+    orEnv->quickHolds[ orEnv->quickHoldsUsed ].dataType = type; \
+    orEnv->quickHolds[ orEnv->quickHoldsUsed ].which = index; \
+    ++orEnv->quickHoldsUsed
+
+#define orRefPop(count)         orEnv->quickHoldsUsed -= count
 
 #define orWordVal(wv,blk,val) \

trunk/orca/tokenize.c

@@ -279 +279 @@
     int  get_mode = 0;
     int  state = ST_START;
+    OIndex hold;
     OValue* prev = 0;
 
@@ -287 +288 @@
         return orBLOCKS + blk_stack[0];
 
-    orRefPush( OT_BLOCK, blk_stack[0] );
+    hold = orHold( OT_BLOCK, blk_stack[0] );
 
     str_term = '}';
@@ -1060 +1061 @@
     }
 
-    orRefPop( 1 );
+    orRelease( hold );
     return BLK_STACK(0);
 
 fail:
 
-    orRefPop( 1 );
+    orRelease( hold );
     return 0;
 }