[strongtalk] r178 committed - Merge nil subclass changes into SVN
codesite...@google.com
Author: StephenLRees
Date: Sat Oct 17 07:54:56 2009
Log: Merge nil subclass changes into SVN
http://code.google.com/p/strongtalk/source/detail?r=178
Modified:
/branches/gcc-linux/StrongtalkSource/VM.dlt
/branches/gcc-linux/test/compiler/compiler_tests.cpp
/branches/gcc-linux/test/main/main.cpp
/branches/gcc-linux/test/prims/behaviorPrimsSuperclassTests.cpp
/branches/gcc-linux/vm/oops/klass.cpp
/branches/gcc-linux/vm/oops/klass.hpp
/branches/gcc-linux/vm/prims/behavior_prims.cpp
/branches/gcc-linux/vm/prims/prims.inc
/branches/gcc-linux/vm/prims/system_prims.cpp
/branches/gcc-linux/vm/prims/system_prims.hpp
/branches/gcc-linux/vm/runtime/os_nt.cpp
=======================================
--- /branches/gcc-linux/StrongtalkSource/VM.dlt Sun Nov 2 17:10:51 2008
+++ /branches/gcc-linux/StrongtalkSource/VM.dlt Sat Oct 17 07:54:56 2009
@@ -304,9 +304,13 @@
ifFalse: [self collectAndAllocate: allocateBlock
ifExpand: expansionBlock]]!
+canScavenge
+
+ ^{{primitiveCanScavenge}}!
+
collectAndAllocate: allocateBlock ifExpand: expansionBlock
- self collectGarbage.
+ self collectIfPossible.
self growIfNecessary.
^[allocateBlock
value: false
@@ -322,6 +326,11 @@
value: [:e2| nil error: e2]]]]
ensure: [self shrinkIfPossible]!
+collectIfPossible
+
+ self canScavenge
+ ifTrue: [self collectGarbage]!
+
expand
|expansionSize|
@@ -485,7 +494,7 @@
|expansions |
expansions := self expansionCount.
- self scavengeGarbage.
+ self scavengeIfPossible.
^(expansions ~~ self expansionCount)
ifTrue: [self collectAndAllocate: allocateBlock
ifExpand: expansionBlock]
@@ -498,6 +507,11 @@
self collectAndAllocate: allocateBlock
ifExpand: expansionBlock]]]!
+scavengeIfPossible
+
+ self canScavenge
+ ifTrue: [self scavengeGarbage]!
+
shrink: size
{{primitiveShrinkMemory: size}}!
=======================================
--- /branches/gcc-linux/test/compiler/compiler_tests.cpp Sun Jun 7
15:02:00 2009
+++ /branches/gcc-linux/test/compiler/compiler_tests.cpp Sat Oct 17
07:54:56 2009
@@ -34,19 +34,19 @@
return nm;
}
void initializeSmalltalkEnvironment() {
- HandleMark mark;
- Handle _new(oopFactory::new_symbol("new"));
- Handle initialize(oopFactory::new_symbol("initialize"));
- Handle processorScheduler(Universe::find_global("ProcessorScheduler"));
- Handle run(oopFactory::new_symbol("run"));
- Handle systemInitializer(Universe::find_global("SystemInitializer"));
-
- Handle processor(Delta::call(processorScheduler.as_oop(),
_new.as_oop()));
- associationOop processorAssoc =
Universe::find_global_association("Processor");
- processorAssoc->set_value(processor.as_oop());
-
- Delta::call(processor.as_oop(), initialize.as_oop());
- Delta::call(systemInitializer.as_oop(), run.as_oop());
+ //HandleMark mark;
+ //Handle _new(oopFactory::new_symbol("new"));
+ //Handle initialize(oopFactory::new_symbol("initialize"));
+ //Handle
processorScheduler(Universe::find_global("ProcessorScheduler"));
+ //Handle run(oopFactory::new_symbol("run"));
+ //Handle systemInitializer(Universe::find_global("SystemInitializer"));
+ //
+ //Handle processor(Delta::call(processorScheduler.as_oop(),
_new.as_oop()));
+ //associationOop processorAssoc =
Universe::find_global_association("Processor");
+ //processorAssoc->set_value(processor.as_oop());
+
+ //Delta::call(processor.as_oop(), initialize.as_oop());
+ //Delta::call(systemInitializer.as_oop(), run.as_oop());
}
void exhaustMethodHeap(LookupKey& key, int requiredSize) {
GrowableArray<nmethod*>* nmethods = new GrowableArray<nmethod*>;
=======================================
--- /branches/gcc-linux/test/main/main.cpp Sun Jun 7 11:35:02 2009
+++ /branches/gcc-linux/test/main/main.cpp Sat Oct 17 07:54:56 2009
@@ -1,6 +1,7 @@
#include "incls/_precompiled.incl"
#include "incls/_shell.cpp.incl"
#include "incls/_delta.cpp.incl"
+#include "handle.hpp"
#include "testharness.h"
#include <windows.h>
@@ -62,19 +63,37 @@
TestDeltaProcess::~TestDeltaProcess() {
set_processObj(processOop(newProcess()));
}
+void initializeSmalltalkEnvironment() {
+ PersistentHandle _new(oopFactory::new_symbol("new"));
+ PersistentHandle initialize(oopFactory::new_symbol("initialize"));
+ PersistentHandle
runBase(oopFactory::new_symbol("runBaseClassInitializers"));
+ PersistentHandle
processorScheduler(Universe::find_global("ProcessorScheduler"));
+ PersistentHandle smalltalk(Universe::find_global("Smalltalk"));
+ PersistentHandle
systemInitializer(Universe::find_global("SystemInitializer"));
+
+ PersistentHandle processor(Delta::call(processorScheduler.as_oop(),
_new.as_oop()));
+ associationOop processorAssoc =
Universe::find_global_association("Processor");
+ processorAssoc->set_value(processor.as_oop());
+
+ Delta::call(processor.as_oop(), initialize.as_oop());
+ Delta::call(systemInitializer.as_oop(), runBase.as_oop());
+ Delta::call(smalltalk.as_oop(), initialize.as_oop());
+}
int TestDeltaProcess::launch_tests(DeltaProcess *process) {
process->suspend_at_creation();
+ {
+ BlockScavenge bs;
+ initializeSmalltalkEnvironment();
+ }
TestRegistry::runAndPrint();
os::signal_event(done);
return 0;
}
-
static int vmLoopLauncher(DeltaProcess* testProcess) {
vmProcess->transfer_to(testProcess);
vmProcess->loop();
return 0;
}
-
void start_vm_process(TestDeltaProcess* testProcess) {
int threadId;
vmProcess = new VMProcess();
=======================================
--- /branches/gcc-linux/test/prims/behaviorPrimsSuperclassTests.cpp Sun Oct
11 14:10:37 2009
+++ /branches/gcc-linux/test/prims/behaviorPrimsSuperclassTests.cpp Sat Oct
17 07:54:56 2009
@@ -11,11 +11,16 @@
PersistentHandle* delta;
PersistentHandle* objectClassHandle;
PersistentHandle* classClassHandle;
+ PersistentHandle* delayClassHandle;
PersistentHandle* metaclassClassHandle;
PersistentHandle* classMetaclass;
PersistentHandle* subclassHandle;
+ PersistentHandle* topClassHandle;
+ PersistentHandle* delaySubclassHandle;
PersistentHandle* superclassHandle;
PersistentHandle* subclassName;
+ PersistentHandle* topClassName;
+ PersistentHandle* delaySubclassName;
PersistentHandle* superclassName;
mixinOop createEmptyMixin() {
@@ -41,7 +46,8 @@
return mixin;
}
- klassOop createClass(symbolOop className) {
+ klassOop createClass(symbolOop className, klassOop superclass) {
+ PersistentHandle superclassHandle(superclass);
char name[100];
{
ResourceMark rm;
@@ -52,7 +58,7 @@
symbolOop format = oopFactory::new_symbol("Oops");
mixinOop mixin = createEmptyMixin();
return klassOop(systemPrimitives::createNamedInvocation(format,
-
objectClassHandle->as_oop(),
+
superclassHandle.as_oop(),
trueObj,
className,
mixin));
@@ -89,15 +95,24 @@
klassOop subclass() {
return subclassHandle->as_klassOop();
}
+ klassOop delaySubclass() {
+ return delaySubclassHandle->as_klassOop();
+ }
klassOop superclass() {
return superclassHandle->as_klassOop();
}
klassOop objectClass() {
return objectClassHandle->as_klassOop();
}
+ klassOop delayClass() {
+ return delayClassHandle->as_klassOop();
+ }
klassOop classClass() {
return classClassHandle->as_klassOop();
}
+ klassOop topClass() {
+ return topClassHandle->as_klassOop();
+ }
klassOop metaclassClass() {
return metaclassClassHandle->as_klassOop();
}
@@ -108,24 +123,44 @@
sprintf(text,"%s. Should be: %s, was: %s", message,
expected->as_string(), unmarkSymbol(result)->as_string());
ASSERT_TRUE_M(unmarkSymbol(result) == expected, text);
}
+ void checkNotMarkedSymbol(oop result) {
+ if (!result->is_mark()) return;
+ ResourceMark rm;
+ char text[200];
+ sprintf(text,"Unexpected marked result was: %s",
unmarkSymbol(result)->as_string());
+ FAIL_M(text);
+ }
END_DECLARE
SETUP(BehaviorPrimitivesSuperclassTests) {
delta = new
PersistentHandle(Universe::find_global("Smalltalk"));
objectClassHandle = new
PersistentHandle(Universe::find_global("Object"));
classClassHandle = new
PersistentHandle(Universe::find_global("Class"));
+ delayClassHandle = new
PersistentHandle(Universe::find_global("Delay"));
metaclassClassHandle = new
PersistentHandle(Universe::find_global("Metaclass"));
classMetaclass = new
PersistentHandle(classClassHandle->as_klassOop()->klass_part()->superKlass());
subclassName = new
PersistentHandle(oopFactory::new_symbol("BehaviorPrimsSubclassFixture"));
superclassName = new
PersistentHandle(oopFactory::new_symbol("BehaviorPrimsSuperclassFixture"));
+ topClassName = new
PersistentHandle(oopFactory::new_symbol("BehaviorPrimsTopClassFixture"));
+ delaySubclassName = new
PersistentHandle(oopFactory::new_symbol("BehaviorPrimsDelayFixture"));
checkDoesntExist(superclassName);
checkDoesntExist(subclassName);
-
- subclassHandle = new
PersistentHandle(createClass(as_symbol(subclassName)));
+ checkDoesntExist(delaySubclassName);
+ checkDoesntExist(topClassName);
+
+ subclassHandle = new
PersistentHandle(createClass(as_symbol(subclassName),
+ objectClass()));
checkClass(subclassHandle);
- superclassHandle = new
PersistentHandle(createClass(as_symbol(superclassName)));
+ superclassHandle = new
PersistentHandle(createClass(as_symbol(superclassName),
+ objectClass()));
checkClass(superclassHandle);
+ delaySubclassHandle = new
PersistentHandle(createClass(as_symbol(delaySubclassName),
+ delayClass()));
+ checkClass(delaySubclassHandle);
+ topClassHandle = new
PersistentHandle(createClass(as_symbol(topClassName),
+ objectClass()));
+ checkClass(topClassHandle);
}
TEARDOWN(BehaviorPrimitivesSuperclassTests){
@@ -133,6 +168,10 @@
remove(subclassName);
if (superclassHandle)
remove(superclassName);
+ if (delaySubclassHandle)
+ remove(delaySubclassName);
+ if (topClassHandle)
+ remove(topClassName);
safeDelete(delta);
safeDelete(classMetaclass);
@@ -140,8 +179,11 @@
safeDelete(metaclassClassHandle);
safeDelete(objectClassHandle);
safeDelete(subclassName);
+ safeDelete(delaySubclassName);
safeDelete(superclassName);
safeDelete(subclassHandle);
+ safeDelete(topClassHandle);
+ safeDelete(delaySubclassHandle);
safeDelete(superclassHandle);
}
@@ -155,6 +197,31 @@
ASSERT_TRUE_M(superclassOf(subclass()->klass()) ==
objectClass()->klass(),
"Metasuperclass should be unchanged");
}
+
+TESTF(BehaviorPrimitivesSuperclassTests,
setSuperclassShouldChangeSuperclassToNil) {
+ ASSERT_TRUE_M(superclassOf(subclass()) == objectClass(), "Original
superclassHandle");
+
+ oop result = behaviorPrimitives::setSuperclass(nilObj, subclass());
+
+ ASSERT_TRUE_M(subclass() == result, "Should return receiver");
+ ASSERT_TRUE_M(superclassOf(subclass()) == nilObj, "Superclass should
have changed");
+ ASSERT_TRUE_M(superclassOf(subclass()->klass()) ==
objectClass()->klass(),
+ "Metasuperclass should be unchanged");
+}
+
+TESTF(BehaviorPrimitivesSuperclassTests,
setSuperclassShouldChangeTopSuperclassToClass) {
+ oop result = behaviorPrimitives::setSuperclass(classClass(),
topClass()->klass());
+
+ checkNotMarkedSymbol(result);
+ ASSERT_TRUE_M(topClass()->klass() == result, "Should return receiver");
+ ASSERT_TRUE_M(superclassOf(topClass()->klass()) ==
classClass(), "Superclass should have changed");
+}
+
+TESTF(BehaviorPrimitivesSuperclassTests,
setSuperclassShouldNotChangeSuperclassToNilWhenSuperclasHasIvars) {
+ oop result = behaviorPrimitives::setSuperclass(nilObj, delaySubclass());
+
+ checkMarkedSymbol("Should report error", result,
vmSymbols::argument_is_invalid());
+}
TESTF(BehaviorPrimitivesSuperclassTests,
setSuperclassShouldReportErrorWhenReceiverNotAClass) {
oop result = behaviorPrimitives::setSuperclass(superclass(),
oopFactory::new_objArray(0));
=======================================
--- /branches/gcc-linux/vm/oops/klass.cpp Sat Oct 10 17:23:44 2009
+++ /branches/gcc-linux/vm/oops/klass.cpp Sat Oct 17 07:54:56 2009
@@ -71,8 +71,6 @@
}
return "Special";
}
-
-
bool Klass::has_same_layout_as(klassOop klass) {
assert(klass->is_klass(), "argument must be klass");
@@ -91,6 +89,26 @@
}
return true;
}
+
+bool Klass::has_same_inst_vars_as(klassOop klass) {
+ assert(klass->is_klass(), "argument must be klass");
+ // Check equality
+ if (as_klassOop() == klass) return true;
+
+ Klass* classPart = klass->klass_part();
+ // Check instance size
+ int ivars = number_of_instance_variables();
+ int classIvars = classPart->number_of_instance_variables();
+ if (ivars != classIvars)
+ return false;
+
+ // Check instance variables
+ for (int offset = 1; offset <= number_of_instance_variables(); offset++)
{
+ if (inst_var_name_at(non_indexable_size() - offset) !=
+ classPart->inst_var_name_at(classPart->non_indexable_size() -
offset)) return false;
+ }
+ return true;
+}
klassOop Klass::create_subclass(mixinOop mixin, Format format) {
ShouldNotCallThis();
=======================================
--- /branches/gcc-linux/vm/oops/klass.hpp Sat Oct 10 17:23:44 2009
+++ /branches/gcc-linux/vm/oops/klass.hpp Sat Oct 17 07:54:56 2009
@@ -165,6 +165,7 @@
// Tells whether the two klass have same layout (format and instance
variables)
bool has_same_layout_as(klassOop klass);
+ bool has_same_inst_vars_as(klassOop klass);
// creates invocation
virtual klassOop create_subclass(mixinOop mixin, Format format);
=======================================
--- /branches/gcc-linux/vm/prims/behavior_prims.cpp Sun Oct 11 14:10:37 2009
+++ /branches/gcc-linux/vm/prims/behavior_prims.cpp Sat Oct 17 07:54:56 2009
@@ -70,16 +70,22 @@
PROLOGUE_2("setSuperclass", receiver, newSuper);
if (!receiver->is_klass())
return markSymbol(vmSymbols::receiver_has_wrong_type());
- if (!newSuper->is_klass())
+ if (!(newSuper->is_klass() || newSuper == nilObj))
return markSymbol(vmSymbols::first_argument_has_wrong_type());
Klass* receiverClass = klassOop(receiver)->klass_part();
Klass* oldSuperclass = receiverClass->superKlass()->klass_part();
- klassOop newSuperclass = klassOop(newSuper);
-
- if (!oldSuperclass->has_same_layout_as(newSuperclass))
- return markSymbol(vmSymbols::invalid_klass());
-
+ klassOop newSuperclass;
+ if (newSuper == nilObj) {
+ newSuperclass = klassOop(nilObj);
+ if (oldSuperclass->number_of_instance_variables() > 0)
+ return markSymbol(vmSymbols::argument_is_invalid());
+ } else {
+ newSuperclass = klassOop(newSuper);
+
+ if (!oldSuperclass->has_same_inst_vars_as(newSuperclass))
+ return markSymbol(vmSymbols::invalid_klass());
+ }
receiverClass->set_superKlass(newSuperclass);
return receiver;
=======================================
--- /branches/gcc-linux/vm/prims/prims.inc Sun Oct 11 14:10:37 2009
+++ /branches/gcc-linux/vm/prims/prims.inc Sat Oct 17 07:54:56 2009
@@ -848,42 +848,42 @@
errors_84
};
-static char* signature_85[] = { "Proxy", "SmallInteger"};
-static char* errors_85[] = { "OutOfBounds", NULL};
+static char* signature_85[] = { "Boolean"};
+static char* errors_85[] = {NULL};
static primitive_desc primitive_85 = {
- "primitiveCharacterFor:ifFail:",
- fntype(&systemPrimitives::characterFor),
- 327681,
+ "primitiveCanScavenge",
+ fntype(&systemPrimitives::canScavenge),
+ 65536,
signature_85,
errors_85
};
-static char* signature_86[] = { "Self class", "Object"};
-static char* errors_86[] = {NULL};
+static char* signature_86[] = { "Proxy", "SmallInteger"};
+static char* errors_86[] = { "OutOfBounds", NULL};
static primitive_desc primitive_86 = {
- "primitiveClass",
- fntype(&oopPrimitives::klass),
- 5767169,
+ "primitiveCharacterFor:ifFail:",
+ fntype(&systemPrimitives::characterFor),
+ 327681,
signature_86,
errors_86
};
-static char* signature_87[] = { "Behavior", "Object"};
+static char* signature_87[] = { "Self class", "Object"};
static char* errors_87[] = {NULL};
static primitive_desc primitive_87 = {
- "primitiveClassOf:",
- fntype(&oopPrimitives::klass_of),
- 4718593,
+ "primitiveClass",
+ fntype(&oopPrimitives::klass),
+ 5767169,
signature_87,
errors_87
};
-static char* signature_88[] = { "Object"};
+static char* signature_88[] = { "Behavior", "Object"};
static char* errors_88[] = {NULL};
static primitive_desc primitive_88 = {
- "primitiveClearInlineCaches",
- fntype(&debugPrimitives::clearInlineCaches),
- 65536,
+ "primitiveClassOf:",
+ fntype(&oopPrimitives::klass_of),
+ 4718593,
signature_88,
errors_88
};
@@ -891,8 +891,8 @@
static char* signature_89[] = { "Object"};
static char* errors_89[] = {NULL};
static primitive_desc primitive_89 = {
- "primitiveClearInvocationCounters",
- fntype(&debugPrimitives::clearInvocationCounters),
+ "primitiveClearInlineCaches",
+ fntype(&debugPrimitives::clearInlineCaches),
65536,
signature_89,
errors_89
@@ -901,8 +901,8 @@
static char* signature_90[] = { "Object"};
static char* errors_90[] = {NULL};
static primitive_desc primitive_90 = {
- "primitiveClearLookupCache",
- fntype(&debugPrimitives::clearLookupCache),
+ "primitiveClearInvocationCounters",
+ fntype(&debugPrimitives::clearInvocationCounters),
65536,
signature_90,
errors_90
@@ -911,8 +911,8 @@
static char* signature_91[] = { "Object"};
static char* errors_91[] = {NULL};
static primitive_desc primitive_91 = {
- "primitiveClearLookupCacheStatistics",
- fntype(&debugPrimitives::clearLookupCacheStatistics),
+ "primitiveClearLookupCache",
+ fntype(&debugPrimitives::clearLookupCache),
65536,
signature_91,
errors_91
@@ -921,8 +921,8 @@
static char* signature_92[] = { "Object"};
static char* errors_92[] = {NULL};
static primitive_desc primitive_92 = {
- "primitiveClearNMethodCounters",
- fntype(&debugPrimitives::clearNMethodCounters),
+ "primitiveClearLookupCacheStatistics",
+ fntype(&debugPrimitives::clearLookupCacheStatistics),
65536,
signature_92,
errors_92
@@ -931,29 +931,29 @@
static char* signature_93[] = { "Object"};
static char* errors_93[] = {NULL};
static primitive_desc primitive_93 = {
- "primitiveClearPrimitiveCounters",
- fntype(&debugPrimitives::clearPrimitiveCounters),
+ "primitiveClearNMethodCounters",
+ fntype(&debugPrimitives::clearNMethodCounters),
65536,
signature_93,
errors_93
};
-static char* signature_94[] = { "Array[String]"};
+static char* signature_94[] = { "Object"};
static char* errors_94[] = {NULL};
static primitive_desc primitive_94 = {
- "primitiveCommandLineArgs",
- fntype(&systemPrimitives::command_line_args),
+ "primitiveClearPrimitiveCounters",
+ fntype(&debugPrimitives::clearPrimitiveCounters),
65536,
signature_94,
errors_94
};
-static char* signature_95[] = { "Block"};
+static char* signature_95[] = { "Array[String]"};
static char* errors_95[] = {NULL};
static primitive_desc primitive_95 = {
- "primitiveCompiledBlockAllocate0",
- fntype(&allocateBlock0),
- 6359040,
+ "primitiveCommandLineArgs",
+ fntype(&systemPrimitives::command_line_args),
+ 65536,
signature_95,
errors_95
};
@@ -961,8 +961,8 @@
static char* signature_96[] = { "Block"};
static char* errors_96[] = {NULL};
static primitive_desc primitive_96 = {
- "primitiveCompiledBlockAllocate1",
- fntype(&allocateBlock1),
+ "primitiveCompiledBlockAllocate0",
+ fntype(&allocateBlock0),
6359040,
signature_96,
errors_96
@@ -971,8 +971,8 @@
static char* signature_97[] = { "Block"};
static char* errors_97[] = {NULL};
static primitive_desc primitive_97 = {
- "primitiveCompiledBlockAllocate2",
- fntype(&allocateBlock2),
+ "primitiveCompiledBlockAllocate1",
+ fntype(&allocateBlock1),
6359040,
signature_97,
errors_97
@@ -981,8 +981,8 @@
static char* signature_98[] = { "Block"};
static char* errors_98[] = {NULL};
static primitive_desc primitive_98 = {
- "primitiveCompiledBlockAllocate3",
- fntype(&allocateBlock3),
+ "primitiveCompiledBlockAllocate2",
+ fntype(&allocateBlock2),
6359040,
signature_98,
errors_98
@@ -991,8 +991,8 @@
static char* signature_99[] = { "Block"};
static char* errors_99[] = {NULL};
static primitive_desc primitive_99 = {
- "primitiveCompiledBlockAllocate4",
- fntype(&allocateBlock4),
+ "primitiveCompiledBlockAllocate3",
+ fntype(&allocateBlock3),
6359040,
signature_99,
errors_99
@@ -1001,8 +1001,8 @@
static char* signature_100[] = { "Block"};
static char* errors_100[] = {NULL};
static primitive_desc primitive_100 = {
- "primitiveCompiledBlockAllocate5",
- fntype(&allocateBlock5),
+ "primitiveCompiledBlockAllocate4",
+ fntype(&allocateBlock4),
6359040,
signature_100,
errors_100
@@ -1011,8 +1011,8 @@
static char* signature_101[] = { "Block"};
static char* errors_101[] = {NULL};
static primitive_desc primitive_101 = {
- "primitiveCompiledBlockAllocate6",
- fntype(&allocateBlock6),
+ "primitiveCompiledBlockAllocate5",
+ fntype(&allocateBlock5),
6359040,
signature_101,
errors_101
@@ -1021,8 +1021,8 @@
static char* signature_102[] = { "Block"};
static char* errors_102[] = {NULL};
static primitive_desc primitive_102 = {
- "primitiveCompiledBlockAllocate7",
- fntype(&allocateBlock7),
+ "primitiveCompiledBlockAllocate6",
+ fntype(&allocateBlock6),
6359040,
signature_102,
errors_102
@@ -1031,8 +1031,8 @@
static char* signature_103[] = { "Block"};
static char* errors_103[] = {NULL};
static primitive_desc primitive_103 = {
- "primitiveCompiledBlockAllocate8",
- fntype(&allocateBlock8),
+ "primitiveCompiledBlockAllocate7",
+ fntype(&allocateBlock7),
6359040,
signature_103,
errors_103
@@ -1041,29 +1041,29 @@
static char* signature_104[] = { "Block"};
static char* errors_104[] = {NULL};
static primitive_desc primitive_104 = {
- "primitiveCompiledBlockAllocate9",
- fntype(&allocateBlock9),
+ "primitiveCompiledBlockAllocate8",
+ fntype(&allocateBlock8),
6359040,
signature_104,
errors_104
};
-static char* signature_105[] = { "Block", "SmallInteger"};
+static char* signature_105[] = { "Block"};
static char* errors_105[] = {NULL};
static primitive_desc primitive_105 = {
- "primitiveCompiledBlockAllocate:",
- fntype(&allocateBlock),
- 2164737,
+ "primitiveCompiledBlockAllocate9",
+ fntype(&allocateBlock9),
+ 6359040,
signature_105,
errors_105
};
-static char* signature_106[] = { "Object"};
+static char* signature_106[] = { "Block", "SmallInteger"};
static char* errors_106[] = {NULL};
static primitive_desc primitive_106 = {
- "primitiveCompiledContextAllocate0",
- fntype(&allocateContext0),
- 6359040,
+ "primitiveCompiledBlockAllocate:",
+ fntype(&allocateBlock),
+ 2164737,
signature_106,
errors_106
};
@@ -1071,8 +1071,8 @@
static char* signature_107[] = { "Object"};
static char* errors_107[] = {NULL};
static primitive_desc primitive_107 = {
- "primitiveCompiledContextAllocate1",
- fntype(&allocateContext1),
+ "primitiveCompiledContextAllocate0",
+ fntype(&allocateContext0),
6359040,
signature_107,
errors_107
@@ -1081,269 +1081,269 @@
static char* signature_108[] = { "Object"};
static char* errors_108[] = {NULL};
static primitive_desc primitive_108 = {
- "primitiveCompiledContextAllocate2",
- fntype(&allocateContext2),
+ "primitiveCompiledContextAllocate1",
+ fntype(&allocateContext1),
6359040,
signature_108,
errors_108
};
-static char* signature_109[] = { "Object", "SmallInteger"};
+static char* signature_109[] = { "Object"};
static char* errors_109[] = {NULL};
static primitive_desc primitive_109 = {
- "primitiveCompiledContextAllocate:",
- fntype(&allocateContext),
- 6359041,
+ "primitiveCompiledContextAllocate2",
+ fntype(&allocateContext2),
+ 6359040,
signature_109,
errors_109
};
-static char* signature_110[] =
{ "Method", "Object", "SmallInteger", "SmallInteger", "Array", "ByteArray", "Array"};
+static char* signature_110[] = { "Object", "SmallInteger"};
static char* errors_110[] = {NULL};
static primitive_desc primitive_110 = {
- "primitiveConstructMethod:flags:nofArgs:debugInfo:bytes:oops:ifFail:",
- fntype(&methodOopPrimitives::constructMethod),
- 327686,
+ "primitiveCompiledContextAllocate:",
+ fntype(&allocateContext),
+ 6359041,
signature_110,
errors_110
};
-static char* signature_111[] = { "Object", "Object"};
-static char* errors_111[] = { "NotOops", NULL};
+static char* signature_111[] =
{ "Method", "Object", "SmallInteger", "SmallInteger", "Array", "ByteArray", "Array"};
+static char* errors_111[] = {NULL};
static primitive_desc primitive_111 = {
- "primitiveCopyTenuredIfFail:",
- fntype(&oopPrimitives::copy_tenured),
- 1376257,
+ "primitiveConstructMethod:flags:nofArgs:debugInfo:bytes:oops:ifFail:",
+ fntype(&methodOopPrimitives::constructMethod),
+ 327686,
signature_111,
errors_111
};
-static char* signature_112[] =
{ "GlobalAssociation", "Mixin", "Symbol", "Boolean", "Behavior", "Symbol"};
-static char* errors_112[] = { "WrongFormat", NULL};
+static char* signature_112[] = { "Object", "Object"};
+static char* errors_112[] = { "NotOops", NULL};
static primitive_desc primitive_112 = {
- "primitiveCreateInvocationOf:named:isPrimaryInvocation:superclass:format:ifFail:",
- fntype(&systemPrimitives::createNamedInvocation),
- 327685,
+ "primitiveCopyTenuredIfFail:",
+ fntype(&oopPrimitives::copy_tenured),
+ 1376257,
signature_112,
errors_112
};
-static char* signature_113[] =
{ "GlobalAssociation", "Mixin", "Behavior", "Symbol"};
+static char* signature_113[] =
{ "GlobalAssociation", "Mixin", "Symbol", "Boolean", "Behavior", "Symbol"};
static char* errors_113[] = { "WrongFormat", NULL};
static primitive_desc primitive_113 = {
- "primitiveCreateInvocationOf:superclass:format:ifFail:",
- fntype(&systemPrimitives::createInvocation),
- 327683,
+ "primitiveCreateInvocationOf:named:isPrimaryInvocation:superclass:format:ifFail:",
+ fntype(&systemPrimitives::createNamedInvocation),
+ 327685,
signature_113,
errors_113
};
-static char* signature_114[] = { "SmallInteger"};
-static char* errors_114[] = {NULL};
+static char* signature_114[] =
{ "GlobalAssociation", "Mixin", "Behavior", "Symbol"};
+static char* errors_114[] = { "WrongFormat", NULL};
static primitive_desc primitive_114 = {
- "primitiveCurrentThreadId",
- fntype(&systemPrimitives::current_thread_id),
- 65536,
+ "primitiveCreateInvocationOf:superclass:format:ifFail:",
+ fntype(&systemPrimitives::createInvocation),
+ 327683,
signature_114,
errors_114
};
-static char* signature_115[] = { "Proxy", "Symbol", "Proxy"};
+static char* signature_115[] = { "SmallInteger"};
static char* errors_115[] = {NULL};
static primitive_desc primitive_115 = {
- "primitiveDLLLoad:result:ifFail:",
- fntype(&systemPrimitives::dll_load),
- 327682,
+ "primitiveCurrentThreadId",
+ fntype(&systemPrimitives::current_thread_id),
+ 65536,
signature_115,
errors_115
};
-static char* signature_116[] = { "Proxy", "Symbol", "Proxy", "Proxy"};
+static char* signature_116[] = { "Proxy", "Symbol", "Proxy"};
static char* errors_116[] = {NULL};
static primitive_desc primitive_116 = {
- "primitiveDLLLookup:in:result:ifFail:",
- fntype(&systemPrimitives::dll_lookup),
- 327683,
+ "primitiveDLLLoad:result:ifFail:",
+ fntype(&systemPrimitives::dll_load),
+ 327682,
signature_116,
errors_116
};
-static char* signature_117[] = { "Object", "Object", "Symbol"};
+static char* signature_117[] = { "Proxy", "Symbol", "Proxy", "Proxy"};
static char* errors_117[] = {NULL};
static primitive_desc primitive_117 = {
- "primitiveDLLSetupLookup:selector:ifFail:",
- fntype(&systemPrimitives::dll_setup),
- 327682,
+ "primitiveDLLLookup:in:result:ifFail:",
+ fntype(&systemPrimitives::dll_lookup),
+ 327683,
signature_117,
errors_117
};
-static char* signature_118[] = { "Object", "Proxy"};
+static char* signature_118[] = { "Object", "Object", "Symbol"};
static char* errors_118[] = {NULL};
static primitive_desc primitive_118 = {
- "primitiveDLLUnload:ifFail:",
- fntype(&systemPrimitives::dll_unload),
- 327681,
+ "primitiveDLLSetupLookup:selector:ifFail:",
+ fntype(&systemPrimitives::dll_setup),
+ 327682,
signature_118,
errors_118
};
-static char* signature_119[] = { "Object"};
+static char* signature_119[] = { "Object", "Proxy"};
static char* errors_119[] = {NULL};
static primitive_desc primitive_119 = {
- "primitiveDecodeAllMethods",
- fntype(&debugPrimitives::decodeAllMethods),
- 65536,
+ "primitiveDLLUnload:ifFail:",
+ fntype(&systemPrimitives::dll_unload),
+ 327681,
signature_119,
errors_119
};
-static char* signature_120[] = { "Object", "Object", "Symbol"};
-static char* errors_120[] = { "NotFound", NULL};
+static char* signature_120[] = { "Object"};
+static char* errors_120[] = {NULL};
static primitive_desc primitive_120 = {
- "primitiveDecodeMethod:ifFail:",
- fntype(&debugPrimitives::decodeMethod),
- 1376258,
+ "primitiveDecodeAllMethods",
+ fntype(&debugPrimitives::decodeAllMethods),
+ 65536,
signature_120,
errors_120
};
-static char* signature_121[] = { "Proxy", "Proxy"};
-static char* errors_121[] = {NULL};
+static char* signature_121[] = { "Object", "Object", "Symbol"};
+static char* errors_121[] = { "NotFound", NULL};
static primitive_desc primitive_121 = {
- "primitiveDefWindowProc:ifFail:",
- fntype(&systemPrimitives::defWindowProc),
- 327681,
+ "primitiveDecodeMethod:ifFail:",
+ fntype(&debugPrimitives::decodeMethod),
+ 1376258,
signature_121,
errors_121
};
-static char* signature_122[] = { "Object"};
+static char* signature_122[] = { "Proxy", "Proxy"};
static char* errors_122[] = {NULL};
static primitive_desc primitive_122 = {
- "primitiveDeoptimizeStacks",
- fntype(&debugPrimitives::deoptimizeStacks),
- 196608,
+ "primitiveDefWindowProc:ifFail:",
+ fntype(&systemPrimitives::defWindowProc),
+ 327681,
signature_122,
errors_122
};
-static char* signature_123[] =
{ "SmallInteger", "SmallInteger", "SmallInteger"};
-static char* errors_123[] = { "Overflow", "DivisionByZero", NULL};
+static char* signature_123[] = { "Object"};
+static char* errors_123[] = {NULL};
static primitive_desc primitive_123 = {
- "primitiveDiv:ifFail:",
- fntype(&smiOopPrimitives_div),
- 6029826,
+ "primitiveDeoptimizeStacks",
+ fntype(&debugPrimitives::deoptimizeStacks),
+ 196608,
signature_123,
errors_123
};
-static char* signature_124[] = { "Float"};
-static char* errors_124[] = {NULL};
+static char* signature_124[] =
{ "SmallInteger", "SmallInteger", "SmallInteger"};
+static char* errors_124[] = { "Overflow", "DivisionByZero", NULL};
static primitive_desc primitive_124 = {
- "primitiveElapsedTime",
- fntype(&systemPrimitives::elapsedTime),
- 65536,
+ "primitiveDiv:ifFail:",
+ fntype(&smiOopPrimitives_div),
+ 6029826,
signature_124,
errors_124
};
-static char* signature_125[] = { "Boolean", "Object", "Object"};
+static char* signature_125[] = { "Float"};
static char* errors_125[] = {NULL};
static primitive_desc primitive_125 = {
- "primitiveEqual:",
- fntype(&oopPrimitives::equal),
- 1572866,
+ "primitiveElapsedTime",
+ fntype(&systemPrimitives::elapsedTime),
+ 65536,
signature_125,
errors_125
};
-static char* signature_126[] = { "Object", "SmallInteger"};
+static char* signature_126[] = { "Boolean", "Object", "Object"};
static char* errors_126[] = {NULL};
static primitive_desc primitive_126 = {
- "primitiveExpandMemory:",
- fntype(&systemPrimitives::expandMemory),
- 65537,
+ "primitiveEqual:",
+ fntype(&oopPrimitives::equal),
+ 1572866,
signature_126,
errors_126
};
-static char* signature_127[] = { "SmallInteger"};
+static char* signature_127[] = { "Object", "SmallInteger"};
static char* errors_127[] = {NULL};
static primitive_desc primitive_127 = {
- "primitiveExpansions",
- fntype(&systemPrimitives::expansions),
- 65536,
+ "primitiveExpandMemory:",
+ fntype(&systemPrimitives::expandMemory),
+ 65537,
signature_127,
errors_127
};
-static char* signature_128[] = { "Process|nil"};
+static char* signature_128[] = { "SmallInteger"};
static char* errors_128[] = {NULL};
static primitive_desc primitive_128 = {
- "primitiveFlatProfilerDisengage",
- fntype(&systemPrimitives::flat_profiler_disengage),
+ "primitiveExpansions",
+ fntype(&systemPrimitives::expansions),
65536,
signature_128,
errors_128
};
-static char* signature_129[] = { "Process", "Process"};
+static char* signature_129[] = { "Process|nil"};
static char* errors_129[] = {NULL};
static primitive_desc primitive_129 = {
- "primitiveFlatProfilerEngage:ifFail:",
- fntype(&systemPrimitives::flat_profiler_engage),
- 327681,
+ "primitiveFlatProfilerDisengage",
+ fntype(&systemPrimitives::flat_profiler_disengage),
+ 65536,
signature_129,
errors_129
};
-static char* signature_130[] = { "Object"};
+static char* signature_130[] = { "Process", "Process"};
static char* errors_130[] = {NULL};
static primitive_desc primitive_130 = {
- "primitiveFlatProfilerPrint",
- fntype(&systemPrimitives::flat_profiler_print),
- 65536,
+ "primitiveFlatProfilerEngage:ifFail:",
+ fntype(&systemPrimitives::flat_profiler_engage),
+ 327681,
signature_130,
errors_130
};
-static char* signature_131[] = { "Process|nil"};
+static char* signature_131[] = { "Object"};
static char* errors_131[] = {NULL};
static primitive_desc primitive_131 = {
- "primitiveFlatProfilerProcess",
- fntype(&systemPrimitives::flat_profiler_process),
+ "primitiveFlatProfilerPrint",
+ fntype(&systemPrimitives::flat_profiler_print),
65536,
signature_131,
errors_131
};
-static char* signature_132[] = { "Object"};
+static char* signature_132[] = { "Process|nil"};
static char* errors_132[] = {NULL};
static primitive_desc primitive_132 = {
- "primitiveFlatProfilerReset",
- fntype(&systemPrimitives::flat_profiler_reset),
+ "primitiveFlatProfilerProcess",
+ fntype(&systemPrimitives::flat_profiler_process),
65536,
signature_132,
errors_132
};
-static char* signature_133[] = { "Float", "Float", "Float"};
+static char* signature_133[] = { "Object"};
static char* errors_133[] = {NULL};
static primitive_desc primitive_133 = {
- "primitiveFloatAdd:ifFail:",
- fntype(&double_add),
- 6030338,
+ "primitiveFlatProfilerReset",
+ fntype(&systemPrimitives::flat_profiler_reset),
+ 65536,
signature_133,
errors_133
};
-static char* signature_134[] = { "Float", "Float"};
+static char* signature_134[] = { "Float", "Float", "Float"};
static char* errors_134[] = {NULL};
static primitive_desc primitive_134 = {
- "primitiveFloatArcCosineIfFail:",
- fntype(&doubleOopPrimitives::arcCosine),
- 1836033,
+ "primitiveFloatAdd:ifFail:",
+ fntype(&double_add),
+ 6030338,
signature_134,
errors_134
};
@@ -1351,8 +1351,8 @@
static char* signature_135[] = { "Float", "Float"};
static char* errors_135[] = {NULL};
static primitive_desc primitive_135 = {
- "primitiveFloatArcSineIfFail:",
- fntype(&doubleOopPrimitives::arcSine),
+ "primitiveFloatArcCosineIfFail:",
+ fntype(&doubleOopPrimitives::arcCosine),
1836033,
signature_135,
errors_135
@@ -1361,29 +1361,29 @@
static char* signature_136[] = { "Float", "Float"};
static char* errors_136[] = {NULL};
static primitive_desc primitive_136 = {
- "primitiveFloatArcTangentIfFail:",
- fntype(&doubleOopPrimitives::arcTangent),
+ "primitiveFloatArcSineIfFail:",
+ fntype(&doubleOopPrimitives::arcSine),
1836033,
signature_136,
errors_136
};
-static char* signature_137[] = { "SmallInteger", "Float"};
-static char* errors_137[] = { "SmallIntegerConversionFailed", NULL};
+static char* signature_137[] = { "Float", "Float"};
+static char* errors_137[] = {NULL};
static primitive_desc primitive_137 = {
- "primitiveFloatAsSmallIntegerIfFail:",
- fntype(&doubleOopPrimitives::asSmallInteger),
+ "primitiveFloatArcTangentIfFail:",
+ fntype(&doubleOopPrimitives::arcTangent),
1836033,
signature_137,
errors_137
};
-static char* signature_138[] = { "Float", "Float"};
-static char* errors_138[] = {NULL};
+static char* signature_138[] = { "SmallInteger", "Float"};
+static char* errors_138[] = { "SmallIntegerConversionFailed", NULL};
static primitive_desc primitive_138 = {
- "primitiveFloatCeiling",
- fntype(&doubleOopPrimitives::ceiling),
- 1573889,
+ "primitiveFloatAsSmallIntegerIfFail:",
+ fntype(&doubleOopPrimitives::asSmallInteger),
+ 1836033,
signature_138,
errors_138
};
@@ -1391,69 +1391,69 @@
static char* signature_139[] = { "Float", "Float"};
static char* errors_139[] = {NULL};
static primitive_desc primitive_139 = {
- "primitiveFloatCosine",
- fntype(&doubleOopPrimitives::cosine),
+ "primitiveFloatCeiling",
+ fntype(&doubleOopPrimitives::ceiling),
1573889,
signature_139,
errors_139
};
-static char* signature_140[] = { "Float", "Float", "Float"};
+static char* signature_140[] = { "Float", "Float"};
static char* errors_140[] = {NULL};
static primitive_desc primitive_140 = {
- "primitiveFloatDivide:ifFail:",
- fntype(&double_divide),
- 6030338,
+ "primitiveFloatCosine",
+ fntype(&doubleOopPrimitives::cosine),
+ 1573889,
signature_140,
errors_140
};
-static char* signature_141[] = { "Boolean", "Float", "Float"};
+static char* signature_141[] = { "Float", "Float", "Float"};
static char* errors_141[] = {NULL};
static primitive_desc primitive_141 = {
- "primitiveFloatEqual:ifFail:",
- fntype(&doubleOopPrimitives::equal),
- 6030082,
+ "primitiveFloatDivide:ifFail:",
+ fntype(&double_divide),
+ 6030338,
signature_141,
errors_141
};
-static char* signature_142[] = { "Float", "Float"};
+static char* signature_142[] = { "Boolean", "Float", "Float"};
static char* errors_142[] = {NULL};
static primitive_desc primitive_142 = {
- "primitiveFloatExp",
- fntype(&doubleOopPrimitives::exp),
- 1573889,
+ "primitiveFloatEqual:ifFail:",
+ fntype(&doubleOopPrimitives::equal),
+ 6030082,
signature_142,
errors_142
};
-static char* signature_143[] = { "SmallInteger", "Float"};
+static char* signature_143[] = { "Float", "Float"};
static char* errors_143[] = {NULL};
static primitive_desc primitive_143 = {
- "primitiveFloatExponent",
- fntype(&doubleOopPrimitives::exponent),
+ "primitiveFloatExp",
+ fntype(&doubleOopPrimitives::exp),
1573889,
signature_143,
errors_143
};
-static char* signature_144[] = { "Float", "Float"};
+static char* signature_144[] = { "SmallInteger", "Float"};
static char* errors_144[] = {NULL};
static primitive_desc primitive_144 = {
- "primitiveFloatFloor",
- fntype(&doubleOopPrimitives::floor),
+ "primitiveFloatExponent",
+ fntype(&doubleOopPrimitives::exponent),
1573889,
signature_144,
errors_144
};
-static char* signature_145[] = { "Boolean", "Float", "Float"};
+static char* signature_145[] = { "Float", "Float"};
static char* errors_145[] = {NULL};
static primitive_desc primitive_145 = {
- "primitiveFloatGreaterThan:ifFail:",
- fntype(&doubleOopPrimitives::greaterThan),
- 6030082,
+ "primitiveFloatFloor",
+ fntype(&doubleOopPrimitives::floor),
+ 1573889,
signature_145,
errors_145
};
@@ -1461,19 +1461,19 @@
static char* signature_146[] = { "Boolean", "Float", "Float"};
static char* errors_146[] = {NULL};
static primitive_desc primitive_146 = {
- "primitiveFloatGreaterThanOrEqual:ifFail:",
- fntype(&doubleOopPrimitives::greaterThanOrEqual),
+ "primitiveFloatGreaterThan:ifFail:",
+ fntype(&doubleOopPrimitives::greaterThan),
6030082,
signature_146,
errors_146
};
-static char* signature_147[] = { "Float", "Float"};
+static char* signature_147[] = { "Boolean", "Float", "Float"};
static char* errors_147[] = {NULL};
static primitive_desc primitive_147 = {
- "primitiveFloatHyperbolicCosineIfFail:",
- fntype(&doubleOopPrimitives::hyperbolicCosine),
- 1836033,
+ "primitiveFloatGreaterThanOrEqual:ifFail:",
+ fntype(&doubleOopPrimitives::greaterThanOrEqual),
+ 6030082,
signature_147,
errors_147
};
@@ -1481,8 +1481,8 @@
static char* signature_148[] = { "Float", "Float"};
static char* errors_148[] = {NULL};
static primitive_desc primitive_148 = {
- "primitiveFloatHyperbolicSineIfFail:",
- fntype(&doubleOopPrimitives::hyperbolicSine),
+ "primitiveFloatHyperbolicCosineIfFail:",
+ fntype(&doubleOopPrimitives::hyperbolicCosine),
1836033,
signature_148,
errors_148
@@ -1491,19 +1491,19 @@
static char* signature_149[] = { "Float", "Float"};
static char* errors_149[] = {NULL};
static primitive_desc primitive_149 = {
- "primitiveFloatHyperbolicTangentIfFail:",
- fntype(&doubleOopPrimitives::hyperbolicTangent),
+ "primitiveFloatHyperbolicSineIfFail:",
+ fntype(&doubleOopPrimitives::hyperbolicSine),
1836033,
signature_149,
errors_149
};
-static char* signature_150[] = { "Boolean", "Float"};
+static char* signature_150[] = { "Float", "Float"};
static char* errors_150[] = {NULL};
static primitive_desc primitive_150 = {
- "primitiveFloatIsFinite",
- fntype(&doubleOopPrimitives::isFinite),
- 1573889,
+ "primitiveFloatHyperbolicTangentIfFail:",
+ fntype(&doubleOopPrimitives::hyperbolicTangent),
+ 1836033,
signature_150,
errors_150
};
@@ -1511,19 +1511,19 @@
static char* signature_151[] = { "Boolean", "Float"};
static char* errors_151[] = {NULL};
static primitive_desc primitive_151 = {
- "primitiveFloatIsNan",
- fntype(&doubleOopPrimitives::isNan),
+ "primitiveFloatIsFinite",
+ fntype(&doubleOopPrimitives::isFinite),
1573889,
signature_151,
errors_151
};
-static char* signature_152[] = { "Boolean", "Float", "Float"};
+static char* signature_152[] = { "Boolean", "Float"};
static char* errors_152[] = {NULL};
static primitive_desc primitive_152 = {
- "primitiveFloatLessThan:ifFail:",
- fntype(&doubleOopPrimitives::lessThan),
- 6030082,
+ "primitiveFloatIsNan",
+ fntype(&doubleOopPrimitives::isNan),
+ 1573889,
signature_152,
errors_152
};
@@ -1531,19 +1531,19 @@
static char* signature_153[] = { "Boolean", "Float", "Float"};
static char* errors_153[] = {NULL};
static primitive_desc primitive_153 = {
- "primitiveFloatLessThanOrEqual:ifFail:",
- fntype(&doubleOopPrimitives::lessThanOrEqual),
+ "primitiveFloatLessThan:ifFail:",
+ fntype(&doubleOopPrimitives::lessThan),
6030082,
signature_153,
errors_153
};
-static char* signature_154[] = { "Float", "Float"};
-static char* errors_154[] = { "ReceiverNotStrictlyPositive", NULL};
+static char* signature_154[] = { "Boolean", "Float", "Float"};
+static char* errors_154[] = {NULL};
static primitive_desc primitive_154 = {
- "primitiveFloatLnIfFail:",
- fntype(&doubleOopPrimitives::ln),
- 1836033,
+ "primitiveFloatLessThanOrEqual:ifFail:",
+ fntype(&doubleOopPrimitives::lessThanOrEqual),
+ 6030082,
signature_154,
errors_154
};
@@ -1551,29 +1551,29 @@
static char* signature_155[] = { "Float", "Float"};
static char* errors_155[] = { "ReceiverNotStrictlyPositive", NULL};
static primitive_desc primitive_155 = {
- "primitiveFloatLog10IfFail:",
- fntype(&doubleOopPrimitives::log10),
+ "primitiveFloatLnIfFail:",
+ fntype(&doubleOopPrimitives::ln),
1836033,
signature_155,
errors_155
};
static char* signature_156[] = { "Float", "Float"};
-static char* errors_156[] = {NULL};
+static char* errors_156[] = { "ReceiverNotStrictlyPositive", NULL};
static primitive_desc primitive_156 = {
- "primitiveFloatMantissa",
- fntype(&doubleOopPrimitives::mantissa),
- 1573889,
+ "primitiveFloatLog10IfFail:",
+ fntype(&doubleOopPrimitives::log10),
+ 1836033,
signature_156,
errors_156
};
-static char* signature_157[] = { "Float"};
+static char* signature_157[] = { "Float", "Float"};
static char* errors_157[] = {NULL};
static primitive_desc primitive_157 = {
- "primitiveFloatMaxValue",
- fntype(&doubleOopPrimitives::min_positive_value),
- 524288,
+ "primitiveFloatMantissa",
+ fntype(&doubleOopPrimitives::mantissa),
+ 1573889,
signature_157,
errors_157
};
@@ -1581,19 +1581,19 @@
static char* signature_158[] = { "Float"};
static char* errors_158[] = {NULL};
static primitive_desc primitive_158 = {
- "primitiveFloatMinPositiveValue",
+ "primitiveFloatMaxValue",
fntype(&doubleOopPrimitives::min_positive_value),
524288,
signature_158,
errors_158
};
-static char* signature_159[] = { "Float", "Float", "Float"};
+static char* signature_159[] = { "Float"};
static char* errors_159[] = {NULL};
static primitive_desc primitive_159 = {
- "primitiveFloatMod:ifFail:",
- fntype(&doubleOopPrimitives::mod),
- 1836034,
+ "primitiveFloatMinPositiveValue",
+ fntype(&doubleOopPrimitives::min_positive_value),
+ 524288,
signature_159,
errors_159
};
@@ -1601,149 +1601,149 @@
static char* signature_160[] = { "Float", "Float", "Float"};
static char* errors_160[] = {NULL};
static primitive_desc primitive_160 = {
- "primitiveFloatMultiply:ifFail:",
- fntype(&double_multiply),
- 6030338,
+ "primitiveFloatMod:ifFail:",
+ fntype(&doubleOopPrimitives::mod),
***The diff for this file has been truncated for email.***
=======================================
--- /branches/gcc-linux/vm/prims/system_prims.cpp Sun Sep 13 14:52:44 2009
+++ /branches/gcc-linux/vm/prims/system_prims.cpp Sat Oct 17 07:54:56 2009
@@ -115,6 +115,12 @@
return Reflection::apply_change(objArrayOop(change));
}
+
+PRIM_DECL_0(systemPrimitives::canScavenge) {
+ PROLOGUE_0("canScavenge")
+
+ return Universe::can_scavenge() ? trueObj : falseObj;
+}
PRIM_DECL_1(systemPrimitives::scavenge, oop receiver) {
PROLOGUE_1("scavenge", receiver)
=======================================
--- /branches/gcc-linux/vm/prims/system_prims.hpp Sun Sep 13 14:52:44 2009
+++ /branches/gcc-linux/vm/prims/system_prims.hpp Sat Oct 17 07:54:56 2009
@@ -84,6 +84,12 @@
//%
static PRIM_DECL_1(scavenge, oop receiver);
+ //%prim
+ // <NoReceiver> primitiveCanScavenge ^<Boolean> =
+ // Internal { name = 'systemPrimitives::canScavenge' }
+ //%
+ static PRIM_DECL_0(canScavenge);
+
//%prim
// <Object> primitiveGarbageCollect ^<Self> =
// Internal { name = 'systemPrimitives::garbageGollect' }
=======================================
--- /branches/gcc-linux/vm/runtime/os_nt.cpp Sun Aug 9 17:16:11 2009
+++ /branches/gcc-linux/vm/runtime/os_nt.cpp Sat Oct 17 07:54:56 2009
@@ -476,7 +476,7 @@
LONG WINAPI testVectoredHandler(struct _EXCEPTION_POINTERS* exceptionInfo)
{
lprintf("Caught exception.\n");
- if (handler && !handling_exception) {
+ if (false && handler && !handling_exception) {
handling_exception = true;
handler((void*)exceptionInfo->ContextRecord->Ebp,
(void*) exceptionInfo->ContextRecord->Esp,