SmallInteger.st
changeset 2650 8a31202275ff
parent 2649 eeff6ccf6356
child 2653 6d9354cf956d
equal deleted inserted replaced
2649:eeff6ccf6356 2650:8a31202275ff
  1448 	     * it could be recompiled or flushed (in the interrupt)
  1448 	     * it could be recompiled or flushed (in the interrupt)
  1449 	     */
  1449 	     */
  1450 	    do {
  1450 	    do {
  1451 		REGISTER OBJFUNC codeVal;
  1451 		REGISTER OBJFUNC codeVal;
  1452 
  1452 
  1453 		if (InterruptPending != nil) __interruptL(@line);
       
  1454 
       
  1455 		if ((codeVal = __BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil) {
  1453 		if ((codeVal = __BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil) {
  1456 		    /*
  1454 		    /*
  1457 		     * arg is a compiled block with code -
  1455 		     * arg is a compiled block with code -
  1458 		     * directly call it without going through Block>>value
  1456 		     * directly call it without going through Block>>value
       
  1457 		     * however, if there is an interrupt, refetch the code pointer.
  1459 		     */
  1458 		     */
  1460 		    /* stay here, while no interrupts are pending ... */
  1459 		    /* stay here, while no interrupts are pending ... */
  1461 		    do {
  1460 		    do {
  1462 		        (*codeVal)(BLOCK_ARG);
  1461 		        (*codeVal)(BLOCK_ARG);
  1463 			if (InterruptPending != nil) break;
  1462 			if (InterruptPending != nil) goto outerLoop;
  1464 		    } while (--tmp);
  1463 		    } while (--tmp);
  1465 		    tmp++;
  1464 	            RETURN (self);
  1466 		} else {
  1465 		} else {
       
  1466 		    if (InterruptPending != nil) __interruptL(@line);
       
  1467 
  1467 		    if (__BlockInstPtr(aBlock)->b_bytecodes != nil) {
  1468 		    if (__BlockInstPtr(aBlock)->b_bytecodes != nil) {
  1468 			/*
  1469 			/*
  1469 			 * arg is a compiled block with bytecode -
  1470 			 * arg is a compiled block with bytecode -
  1470 			 * directly call interpreter without going through Block>>value
  1471 			 * directly call interpreter without going through Block>>value
  1471 			 */
  1472 			 */
  1475 			 * arg is something else - call it with #value
  1476 			 * arg is something else - call it with #value
  1476 			 */
  1477 			 */
  1477 			(*blockVal.ilc_func)(aBlock, @symbol(value), nil, &blockVal);
  1478 			(*blockVal.ilc_func)(aBlock, @symbol(value), nil, &blockVal);
  1478 		    }
  1479 		    }
  1479 		}
  1480 		}
  1480 	    } while(--tmp);
  1481     outerLoop: ;
       
  1482 	    } while (--tmp);
  1481 
  1483 
  1482 #           undef BLOCK_ARG
  1484 #           undef BLOCK_ARG
  1483 #           undef IBLOCK_ARG
  1485 #           undef IBLOCK_ARG
  1484 
  1486 
  1485 	    RETURN (self);
  1487 	    RETURN (self);
  1865 	     * it could be recompiled or flushed (in the interrupt)
  1867 	     * it could be recompiled or flushed (in the interrupt)
  1866 	     */
  1868 	     */
  1867 	    while (tmp <= final) {
  1869 	    while (tmp <= final) {
  1868 		REGISTER OBJFUNC codeVal;
  1870 		REGISTER OBJFUNC codeVal;
  1869 
  1871 
  1870 		if (InterruptPending != nil) __interruptL(@line);
       
  1871 
       
  1872 		if ((codeVal = __BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil) {
  1872 		if ((codeVal = __BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil) {
  1873 		    /*
  1873 		    /*
  1874 		     * arg is a compiled block with code -
  1874 		     * arg is a compiled block with code -
  1875 		     * directly call it without going through Block>>value
  1875 		     * directly call it without going through Block>>value
  1876 		     */
  1876 		     */
  1877 		    (*codeVal)(BLOCK_ARG, __MKSMALLINT(tmp));
  1877 
       
  1878                     /* stay here, while no interrupts are pending ... */
       
  1879                     do {
       
  1880                         (*codeVal)(BLOCK_ARG, __MKSMALLINT(tmp));
       
  1881                         if (InterruptPending != nil) goto outerLoop;
       
  1882 			tmp++;
       
  1883                     } while (tmp <= final);
       
  1884 		    RETURN (self);
  1878 		} else {
  1885 		} else {
       
  1886 		    if (InterruptPending != nil) __interruptL(@line);
       
  1887 
  1879 		    if (__BlockInstPtr(aBlock)->b_bytecodes != nil) {
  1888 		    if (__BlockInstPtr(aBlock)->b_bytecodes != nil) {
  1880 			/*
  1889 			/*
  1881 			 * arg is a compiled block with bytecode -
  1890 			 * arg is a compiled block with bytecode -
  1882 			 * directly call interpreter without going through Block>>value
  1891 			 * directly call interpreter without going through Block>>value
  1883 			 */
  1892 			 */
  1897 			 * arg is something else - call it with #value:
  1906 			 * arg is something else - call it with #value:
  1898 			 */
  1907 			 */
  1899 			(*blockVal.ilc_func)(aBlock, @symbol(value:), nil, &blockVal, __MKSMALLINT(tmp));
  1908 			(*blockVal.ilc_func)(aBlock, @symbol(value:), nil, &blockVal, __MKSMALLINT(tmp));
  1900 		    }
  1909 		    }
  1901 		}
  1910 		}
  1902 		tmp ++;
  1911 	    outerLoop: ;
       
  1912 		tmp++;
  1903 	    }
  1913 	    }
       
  1914 
  1904 #           undef BLOCK_ARG
  1915 #           undef BLOCK_ARG
  1905 #           undef IBLOCK_ARG
  1916 #           undef IBLOCK_ARG
  1906 	} else {
  1917 
  1907 	    /*
  1918 	    RETURN (self);
  1908 	     * arg is something else - call it with #value:
  1919 	}
  1909 	     */
  1920 	/*
  1910 	    while (tmp <= final) {
  1921 	 * arg is something else - call it with #value:
  1911 		if (InterruptPending != nil) __interruptL(@line);
  1922 	 */
  1912 
  1923 	while (tmp <= final) {
  1913 		(*blockVal.ilc_func)(aBlock, 
  1924 	    if (InterruptPending != nil) __interruptL(@line);
       
  1925 
       
  1926 	    (*blockVal.ilc_func)(aBlock, 
  1914 					 @symbol(value:), 
  1927 					 @symbol(value:), 
  1915 					 nil, &blockVal,
  1928 					 nil, &blockVal,
  1916 					 __MKSMALLINT(tmp));
  1929 					 __MKSMALLINT(tmp));
  1917 		tmp ++;
  1930 	    tmp++;
  1918 	    }
       
  1919 	}
  1931 	}
  1920 	RETURN ( self );
  1932 	RETURN ( self );
  1921     }
  1933     }
  1922 #endif /* WIN32 */
  1934 #endif /* WIN32 */
  1923 %}.
  1935 %}.
  2362 ! !
  2374 ! !
  2363 
  2375 
  2364 !SmallInteger class methodsFor:'documentation'!
  2376 !SmallInteger class methodsFor:'documentation'!
  2365 
  2377 
  2366 version
  2378 version
  2367     ^ '$Header: /cvs/stx/stx/libbasic/SmallInteger.st,v 1.74 1997-05-15 20:18:12 cg Exp $'
  2379     ^ '$Header: /cvs/stx/stx/libbasic/SmallInteger.st,v 1.75 1997-05-16 15:04:58 cg Exp $'
  2368 ! !
  2380 ! !