vm: rename vm:cell to cell_t. it's just a typedef.....

diff --git a/basis/vm/vm.factor b/basis/vm/vm.factor
index 6739701e5328507281b9d14207d14e8f6162a2d9..f3f22923559fd61c6b650635912dc95c35c6838f 100644 (file)
--- a/basis/vm/vm.factor
+++ b/basis/vm/vm.factor
@@ -3,36 +3,36 @@
 USING: classes.struct alien.c-types alien.syntax kernel.private ;
 IN: vm
 
-TYPEDEF: uintptr_t cell
+TYPEDEF: uintptr_t cell_t
 
 STRUCT: context
 { callstack-top void* }
 { callstack-bottom void* }
-{ datastack cell }
-{ retainstack cell }
-{ callstack-save cell }
+{ datastack cell_t }
+{ retainstack cell_t }
+{ callstack-save cell_t }
 { datastack-region void* }
 { retainstack-region void* }
 { callstack-region void* }
-{ context-objects cell[context-object-count] } ;
+{ context-objects cell_t[context-object-count] } ;
 
 : context-field-offset ( field -- offset ) context offset-of ; inline
 
 STRUCT: zone
-{ here cell }
-{ start cell }
-{ end cell }
-{ size cell } ;
+{ here cell_t }
+{ start cell_t }
+{ end cell_t }
+{ size cell_t } ;
 
 STRUCT: vm
 { ctx context* }
 { spare-ctx context* }
 { nursery zone }
-{ cards-offset cell }
-{ decks-offset cell }
-{ signal-handler-addr cell }
-{ faulting? cell }
-{ special-objects cell[special-object-count] } ;
+{ cards-offset cell_t }
+{ decks-offset cell_t }
+{ signal-handler-addr cell_t }
+{ faulting? cell_t }
+{ special-objects cell_t[special-object-count] } ;
 
 : vm-field-offset ( field -- offset ) vm offset-of ; inline
 
@@ -44,24 +44,24 @@ CONSTANT: collect-compact-op 4
 CONSTANT: collect-growing-heap-op 5
 
 STRUCT: copying-sizes
-{ size cell }
-{ occupied cell }
-{ free cell } ;
+{ size cell_t }
+{ occupied cell_t }
+{ free cell_t } ;
 
 STRUCT: mark-sweep-sizes
-{ size cell }
-{ occupied cell }
-{ total-free cell }
-{ contiguous-free cell }
-{ free-block-count cell } ;
+{ size cell_t }
+{ occupied cell_t }
+{ total-free cell_t }
+{ contiguous-free cell_t }
+{ free-block-count cell_t } ;
 
 STRUCT: data-heap-room
 { nursery copying-sizes }
 { aging copying-sizes }
 { tenured mark-sweep-sizes }
-{ cards cell }
-{ decks cell }
-{ mark-stack cell } ;
+{ cards cell_t }
+{ decks cell_t }
+{ mark-stack cell_t } ;
 
 STRUCT: gc-event
 { op uint }
@@ -69,28 +69,28 @@ STRUCT: gc-event
 { code-heap-before mark-sweep-sizes }
 { data-heap-after data-heap-room }
 { code-heap-after mark-sweep-sizes }
-{ cards-scanned cell }
-{ decks-scanned cell }
-{ code-blocks-scanned cell }
+{ cards-scanned cell_t }
+{ decks-scanned cell_t }
+{ code-blocks-scanned cell_t }
 { start-time ulonglong }
-{ total-time cell }
-{ card-scan-time cell }
-{ code-scan-time cell }
-{ data-sweep-time cell }
-{ code-sweep-time cell }
-{ compaction-time cell }
+{ total-time cell_t }
+{ card-scan-time cell_t }
+{ code-scan-time cell_t }
+{ data-sweep-time cell_t }
+{ code-sweep-time cell_t }
+{ compaction-time cell_t }
 { temp-time ulonglong } ;
 
 STRUCT: dispatch-statistics
-{ megamorphic-cache-hits cell }
-{ megamorphic-cache-misses cell }
+{ megamorphic-cache-hits cell_t }
+{ megamorphic-cache-misses cell_t }
 
-{ cold-call-to-ic-transitions cell }
-{ ic-to-pic-transitions cell }
-{ pic-to-mega-transitions cell }
+{ cold-call-to-ic-transitions cell_t }
+{ ic-to-pic-transitions cell_t }
+{ pic-to-mega-transitions cell_t }
 
-{ pic-tag-count cell }
-{ pic-tuple-count cell } ;
+{ pic-tag-count cell_t }
+{ pic-tuple-count cell_t } ;
 
 ! gc-info should be kept in sync with:
 !   vm/gc_info.hpp