00001 static char* signature_0[] = { "Proxy", "Proxy", "Proxy"};
00002 static char* errors_0[] = {NULL};
00003 static primitive_desc primitive_0 = {
00004 "primitiveAPICallResult:ifFail:",
00005 fntype(&proxyOopPrimitives::callOut0),
00006 1507330,
00007 signature_0,
00008 errors_0
00009 };
00010
00011 static char* signature_1[] = { "Proxy", "Proxy", "Proxy|SmallInteger", "Proxy"};
00012 static char* errors_1[] = {NULL};
00013 static primitive_desc primitive_1 = {
00014 "primitiveAPICallValue:result:ifFail:",
00015 fntype(&proxyOopPrimitives::callOut1),
00016 1507331,
00017 signature_1,
00018 errors_1
00019 };
00020
00021 static char* signature_2[] = { "Proxy", "Proxy", "Proxy|SmallInteger", "Proxy|SmallInteger", "Proxy"};
00022 static char* errors_2[] = {NULL};
00023 static primitive_desc primitive_2 = {
00024 "primitiveAPICallValue:value:result:ifFail:",
00025 fntype(&proxyOopPrimitives::callOut2),
00026 1507332,
00027 signature_2,
00028 errors_2
00029 };
00030
00031 static char* signature_3[] = { "Proxy", "Proxy", "Proxy|SmallInteger", "Proxy|SmallInteger", "Proxy|SmallInteger", "Proxy"};
00032 static char* errors_3[] = {NULL};
00033 static primitive_desc primitive_3 = {
00034 "primitiveAPICallValue:value:value:result:ifFail:",
00035 fntype(&proxyOopPrimitives::callOut3),
00036 1507333,
00037 signature_3,
00038 errors_3
00039 };
00040
00041 static char* signature_4[] = { "Proxy", "Proxy", "Proxy|SmallInteger", "Proxy|SmallInteger", "Proxy|SmallInteger", "Proxy|SmallInteger", "Proxy"};
00042 static char* errors_4[] = {NULL};
00043 static primitive_desc primitive_4 = {
00044 "primitiveAPICallValue:value:value:value:result:ifFail:",
00045 fntype(&proxyOopPrimitives::callOut4),
00046 1507334,
00047 signature_4,
00048 errors_4
00049 };
00050
00051 static char* signature_5[] = { "Proxy", "Proxy", "Proxy|SmallInteger", "Proxy|SmallInteger", "Proxy|SmallInteger", "Proxy|SmallInteger", "Proxy|SmallInteger", "Proxy"};
00052 static char* errors_5[] = {NULL};
00053 static primitive_desc primitive_5 = {
00054 "primitiveAPICallValue:value:value:value:value:result:ifFail:",
00055 fntype(&proxyOopPrimitives::callOut5),
00056 1507335,
00057 signature_5,
00058 errors_5
00059 };
00060
00061 static char* signature_6[] = { "IndexedInstanceVariables", "Activation"};
00062 static char* errors_6[] = {NULL};
00063 static primitive_desc primitive_6 = {
00064 "primitiveActivationArgumentsIfFail:",
00065 fntype(&vframeOopPrimitives::arguments),
00066 1835009,
00067 signature_6,
00068 errors_6
00069 };
00070
00071 static char* signature_7[] = { "SmallInteger", "Activation"};
00072 static char* errors_7[] = {NULL};
00073 static primitive_desc primitive_7 = {
00074 "primitiveActivationByteCodeIndexIfFail:",
00075 fntype(&vframeOopPrimitives::byte_code_index),
00076 1835009,
00077 signature_7,
00078 errors_7
00079 };
00080
00081 static char* signature_8[] = { "IndexedInstanceVariables", "Activation"};
00082 static char* errors_8[] = {NULL};
00083 static primitive_desc primitive_8 = {
00084 "primitiveActivationExpressionStackIfFail:",
00085 fntype(&vframeOopPrimitives::expression_stack),
00086 1835009,
00087 signature_8,
00088 errors_8
00089 };
00090
00091 static char* signature_9[] = { "SmallInteger", "Activation"};
00092 static char* errors_9[] = {NULL};
00093 static primitive_desc primitive_9 = {
00094 "primitiveActivationIndex",
00095 fntype(&vframeOopPrimitives::index),
00096 1572865,
00097 signature_9,
00098 errors_9
00099 };
00100
00101 static char* signature_10[] = { "Boolean", "Activation"};
00102 static char* errors_10[] = {NULL};
00103 static primitive_desc primitive_10 = {
00104 "primitiveActivationIsSmalltalkActivationIfFail:",
00105 fntype(&vframeOopPrimitives::is_smalltalk_activation),
00106 1835009,
00107 signature_10,
00108 errors_10
00109 };
00110
00111 static char* signature_11[] = { "SmallInteger", "Activation"};
00112 static char* errors_11[] = {NULL};
00113 static primitive_desc primitive_11 = {
00114 "primitiveActivationMethodIfFail:",
00115 fntype(&vframeOopPrimitives::method),
00116 1835009,
00117 signature_11,
00118 errors_11
00119 };
00120
00121 static char* signature_12[] = { "IndexedByteInstanceVariables", "Activation"};
00122 static char* errors_12[] = {NULL};
00123 static primitive_desc primitive_12 = {
00124 "primitiveActivationPrettyPrintIfFail:",
00125 fntype(&vframeOopPrimitives::pretty_print),
00126 1835009,
00127 signature_12,
00128 errors_12
00129 };
00130
00131 static char* signature_13[] = { "SmallInteger", "Activation"};
00132 static char* errors_13[] = {NULL};
00133 static primitive_desc primitive_13 = {
00134 "primitiveActivationProcess",
00135 fntype(&vframeOopPrimitives::index),
00136 1572865,
00137 signature_13,
00138 errors_13
00139 };
00140
00141 static char* signature_14[] = { "SmallInteger", "Activation"};
00142 static char* errors_14[] = {NULL};
00143 static primitive_desc primitive_14 = {
00144 "primitiveActivationReceiverIfFail:",
00145 fntype(&vframeOopPrimitives::receiver),
00146 1835009,
00147 signature_14,
00148 errors_14
00149 };
00150
00151 static char* signature_15[] = { "IndexedInstanceVariables", "Activation"};
00152 static char* errors_15[] = {NULL};
00153 static primitive_desc primitive_15 = {
00154 "primitiveActivationTemporariesIfFail:",
00155 fntype(&vframeOopPrimitives::temporaries),
00156 1835009,
00157 signature_15,
00158 errors_15
00159 };
00160
00161 static char* signature_16[] = { "SmallInteger", "Activation"};
00162 static char* errors_16[] = {NULL};
00163 static primitive_desc primitive_16 = {
00164 "primitiveActivationTimeStamp",
00165 fntype(&vframeOopPrimitives::time_stamp),
00166 1572865,
00167 signature_16,
00168 errors_16
00169 };
00170
00171 static char* signature_17[] = { "SmallInteger", "SmallInteger", "SmallInteger"};
00172 static char* errors_17[] = { "Overflow", NULL};
00173 static primitive_desc primitive_17 = {
00174 "primitiveAdd:ifFail:",
00175 fntype(&smiOopPrimitives_add),
00176 6029826,
00177 signature_17,
00178 errors_17
00179 };
00180
00181 static char* signature_18[] = { "IndexedInstanceVariables", "SmallInteger"};
00182 static char* errors_18[] = {NULL};
00183 static primitive_desc primitive_18 = {
00184 "primitiveAllObjectsLimit:ifFail:",
00185 fntype(&systemPrimitives::all_objects),
00186 327681,
00187 signature_18,
00188 errors_18
00189 };
00190
00191 static char* signature_19[] = { "Object", "IndexedInstanceVariables"};
00192 static char* errors_19[] = {NULL};
00193 static primitive_desc primitive_19 = {
00194 "primitiveApplyChange:ifFail:",
00195 fntype(&systemPrimitives::applyChange),
00196 327681,
00197 signature_19,
00198 errors_19
00199 };
00200
00201 static char* signature_20[] = { "Float", "SmallInteger"};
00202 static char* errors_20[] = {NULL};
00203 static primitive_desc primitive_20 = {
00204 "primitiveAsFloat",
00205 fntype(&double_from_smi),
00206 1573377,
00207 signature_20,
00208 errors_20
00209 };
00210
00211 static char* signature_21[] = { "SmallInteger", "Object"};
00212 static char* errors_21[] = {NULL};
00213 static primitive_desc primitive_21 = {
00214 "primitiveAsObjectID",
00215 fntype(&oopPrimitives::asObjectID),
00216 1114113,
00217 signature_21,
00218 errors_21
00219 };
00220
00221 static char* signature_22[] = { "Object", "SmallInteger"};
00222 static char* errors_22[] = { "OutOfBounds", NULL};
00223 static primitive_desc primitive_22 = {
00224 "primitiveAsObjectIfFail:",
00225 fntype(&smiOopPrimitives::asObject),
00226 1310721,
00227 signature_22,
00228 errors_22
00229 };
00230
00231 static char* signature_23[] = { "Object", "Object", "Object"};
00232 static char* errors_23[] = { "RecieverHasWrongType", NULL};
00233 static primitive_desc primitive_23 = {
00234 "primitiveBecome:ifFail:",
00235 fntype(&oopPrimitives::become),
00236 1376258,
00237 signature_23,
00238 errors_23
00239 };
00240
00241 static char* signature_24[] = { "GlobalAssociation", "Behavior", "SmallInteger"};
00242 static char* errors_24[] = { "OutOfBounds", NULL};
00243 static primitive_desc primitive_24 = {
00244 "primitiveBehavior:classVariableAt:ifFail:",
00245 fntype(&behaviorPrimitives::classVariableAt),
00246 327682,
00247 signature_24,
00248 errors_24
00249 };
00250
00251 static char* signature_25[] = { "IndexedInstanceVariables", "Behavior"};
00252 static char* errors_25[] = { "OutOfBounds", NULL};
00253 static primitive_desc primitive_25 = {
00254 "primitiveBehavior:classVariablesIfFail:",
00255 fntype(&behaviorPrimitives::classVariables),
00256 327681,
00257 signature_25,
00258 errors_25
00259 };
00260
00261 static char* signature_26[] = { "Boolean", "Behavior"};
00262 static char* errors_26[] = {NULL};
00263 static primitive_desc primitive_26 = {
00264 "primitiveBehaviorCanBeSubclassed:ifFail:",
00265 fntype(&behaviorPrimitives::can_be_subclassed),
00266 327681,
00267 signature_26,
00268 errors_26
00269 };
00270
00271 static char* signature_27[] = { "Boolean", "Behavior"};
00272 static char* errors_27[] = {NULL};
00273 static primitive_desc primitive_27 = {
00274 "primitiveBehaviorCanHaveInstanceVariables:ifFail:",
00275 fntype(&behaviorPrimitives::can_have_instance_variables),
00276 327681,
00277 signature_27,
00278 errors_27
00279 };
00280
00281 static char* signature_28[] = { "Symbol", "Behavior"};
00282 static char* errors_28[] = {NULL};
00283 static primitive_desc primitive_28 = {
00284 "primitiveBehaviorFormat:ifFail:",
00285 fntype(&behaviorPrimitives::format),
00286 327681,
00287 signature_28,
00288 errors_28
00289 };
00290
00291 static char* signature_29[] = { "SmallInteger", "Behavior"};
00292 static char* errors_29[] = {NULL};
00293 static primitive_desc primitive_29 = {
00294 "primitiveBehaviorHeaderSizeOf:ifFail:",
00295 fntype(&behaviorPrimitives::headerSize),
00296 327681,
00297 signature_29,
00298 errors_29
00299 };
00300
00301 static char* signature_30[] = { "Boolean", "Behavior", "Object"};
00302 static char* errors_30[] = {NULL};
00303 static primitive_desc primitive_30 = {
00304 "primitiveBehaviorIsClassOf:",
00305 fntype(&behaviorPrimitives::is_class_of),
00306 5308418,
00307 signature_30,
00308 errors_30
00309 };
00310
00311 static char* signature_31[] = { "Boolean", "Behavior"};
00312 static char* errors_31[] = {NULL};
00313 static primitive_desc primitive_31 = {
00314 "primitiveBehaviorIsSpecializedClass:ifFail:",
00315 fntype(&behaviorPrimitives::is_specialized_class),
00316 327681,
00317 signature_31,
00318 errors_31
00319 };
00320
00321 static char* signature_32[] = { "Mixin", "Behavior"};
00322 static char* errors_32[] = {NULL};
00323 static primitive_desc primitive_32 = {
00324 "primitiveBehaviorMixinOf:ifFail:",
00325 fntype(&behaviorPrimitives::mixinOf),
00326 327681,
00327 signature_32,
00328 errors_32
00329 };
00330
00331 static char* signature_33[] = { "SmallInteger", "Behavior"};
00332 static char* errors_33[] = {NULL};
00333 static primitive_desc primitive_33 = {
00334 "primitiveBehaviorNonIndexableSizeOf:ifFail:",
00335 fntype(&behaviorPrimitives::nonIndexableSize),
00336 327681,
00337 signature_33,
00338 errors_33
00339 };
00340
00341 static char* signature_34[] = { "Symbol", "Behavior"};
00342 static char* errors_34[] = {NULL};
00343 static primitive_desc primitive_34 = {
00344 "primitiveBehaviorVMType:ifFail:",
00345 fntype(&behaviorPrimitives::vm_type),
00346 327681,
00347 signature_34,
00348 errors_34
00349 };
00350
00351 static char* signature_35[] = { "SmallInteger", "SmallInteger", "SmallInteger"};
00352 static char* errors_35[] = {NULL};
00353 static primitive_desc primitive_35 = {
00354 "primitiveBitAnd:ifFail:",
00355 fntype(&smiOopPrimitives::bitAnd),
00356 6029826,
00357 signature_35,
00358 errors_35
00359 };
00360
00361 static char* signature_36[] = { "SmallInteger", "SmallInteger", "SmallInteger"};
00362 static char* errors_36[] = {NULL};
00363 static primitive_desc primitive_36 = {
00364 "primitiveBitOr:ifFail:",
00365 fntype(&smiOopPrimitives::bitOr),
00366 6029826,
00367 signature_36,
00368 errors_36
00369 };
00370
00371 static char* signature_37[] = { "SmallInteger", "SmallInteger", "SmallInteger"};
00372 static char* errors_37[] = {NULL};
00373 static primitive_desc primitive_37 = {
00374 "primitiveBitShift:ifFail:",
00375 fntype(&smiOopPrimitives::bitShift),
00376 6029826,
00377 signature_37,
00378 errors_37
00379 };
00380
00381 static char* signature_38[] = { "SmallInteger", "SmallInteger", "SmallInteger"};
00382 static char* errors_38[] = {NULL};
00383 static primitive_desc primitive_38 = {
00384 "primitiveBitXor:ifFail:",
00385 fntype(&smiOopPrimitives::bitXor),
00386 6029826,
00387 signature_38,
00388 errors_38
00389 };
00390
00391 static char* signature_39[] = { "Boolean", "Block"};
00392 static char* errors_39[] = {NULL};
00393 static primitive_desc primitive_39 = {
00394 "primitiveBlockIsOptimized",
00395 fntype(&block_is_optimized),
00396 1114113,
00397 signature_39,
00398 errors_39
00399 };
00400
00401 static char* signature_40[] = { "Method", "Block"};
00402 static char* errors_40[] = {NULL};
00403 static primitive_desc primitive_40 = {
00404 "primitiveBlockMethod",
00405 fntype(&block_method),
00406 1114113,
00407 signature_40,
00408 errors_40
00409 };
00410
00411 static char* signature_41[] = { "Boolean", "Symbol"};
00412 static char* errors_41[] = { "NotFound", NULL};
00413 static primitive_desc primitive_41 = {
00414 "primitiveBooleanFlagAt:ifFail:",
00415 fntype(&debugPrimitives::boolAt),
00416 327681,
00417 signature_41,
00418 errors_41
00419 };
00420
00421 static char* signature_42[] = { "Boolean", "Symbol", "Boolean"};
00422 static char* errors_42[] = { "NotFound", NULL};
00423 static primitive_desc primitive_42 = {
00424 "primitiveBooleanFlagAt:put:ifFail:",
00425 fntype(&debugPrimitives::boolAtPut),
00426 327682,
00427 signature_42,
00428 errors_42
00429 };
00430
00431 static char* signature_43[] = { "Object"};
00432 static char* errors_43[] = {NULL};
00433 static primitive_desc primitive_43 = {
00434 "primitiveBreakpoint",
00435 fntype(&systemPrimitives::breakpoint),
00436 65536,
00437 signature_43,
00438 errors_43
00439 };
00440
00441 static char* signature_44[] = { "Object", "Object", "Proxy"};
00442 static char* errors_44[] = {NULL};
00443 static primitive_desc primitive_44 = {
00444 "primitiveCallBackInvokeC2:ifFail:",
00445 fntype(&callBackPrimitives::invokeC),
00446 1376258,
00447 signature_44,
00448 errors_44
00449 };
00450
00451 static char* signature_45[] = { "Object", "Object", "Proxy"};
00452 static char* errors_45[] = {NULL};
00453 static primitive_desc primitive_45 = {
00454 "primitiveCallBackInvokePascal2:ifFail:",
00455 fntype(&callBackPrimitives::invokePascal),
00456 1376258,
00457 signature_45,
00458 errors_45
00459 };
00460
00461 static char* signature_46[] = { "Object", "Object", "Symbol"};
00462 static char* errors_46[] = {NULL};
00463 static primitive_desc primitive_46 = {
00464 "primitiveCallBackReceiver:selector:ifFail:",
00465 fntype(&callBackPrimitives::initialize),
00466 327682,
00467 signature_46,
00468 errors_46
00469 };
00470
00471 static char* signature_47[] = { "Object", "SmallInteger", "Proxy"};
00472 static char* errors_47[] = {NULL};
00473 static primitive_desc primitive_47 = {
00474 "primitiveCallBackRegisterCCall:result:ifFail:",
00475 fntype(&callBackPrimitives::registerCCall),
00476 327682,
00477 signature_47,
00478 errors_47
00479 };
00480
00481 static char* signature_48[] = { "Object", "SmallInteger", "SmallInteger", "Proxy"};
00482 static char* errors_48[] = {NULL};
00483 static primitive_desc primitive_48 = {
00484 "primitiveCallBackRegisterPascalCall:numberOfArguments:result:ifFail:",
00485 fntype(&callBackPrimitives::registerPascalCall),
00486 327683,
00487 signature_48,
00488 errors_48
00489 };
00490
00491 static char* signature_49[] = { "Object", "Object", "Proxy"};
00492 static char* errors_49[] = {NULL};
00493 static primitive_desc primitive_49 = {
00494 "primitiveCallBackUnregister:ifFail:",
00495 fntype(&callBackPrimitives::unregister),
00496 1376258,
00497 signature_49,
00498 errors_49
00499 };
00500
00501 static char* signature_50[] = { "Proxy", "SmallInteger"};
00502 static char* errors_50[] = { "OutOfBounds", NULL};
00503 static primitive_desc primitive_50 = {
00504 "primitiveCharacterFor:ifFail:",
00505 fntype(&systemPrimitives::characterFor),
00506 327681,
00507 signature_50,
00508 errors_50
00509 };
00510
00511 static char* signature_51[] = { "Self class", "Object"};
00512 static char* errors_51[] = {NULL};
00513 static primitive_desc primitive_51 = {
00514 "primitiveClass",
00515 fntype(&oopPrimitives::klass),
00516 5767169,
00517 signature_51,
00518 errors_51
00519 };
00520
00521 static char* signature_52[] = { "Behavior", "Object"};
00522 static char* errors_52[] = {NULL};
00523 static primitive_desc primitive_52 = {
00524 "primitiveClassOf:",
00525 fntype(&oopPrimitives::klass_of),
00526 4718593,
00527 signature_52,
00528 errors_52
00529 };
00530
00531 static char* signature_53[] = { "Object"};
00532 static char* errors_53[] = {NULL};
00533 static primitive_desc primitive_53 = {
00534 "primitiveClearInlineCaches",
00535 fntype(&debugPrimitives::clearInlineCaches),
00536 65536,
00537 signature_53,
00538 errors_53
00539 };
00540
00541 static char* signature_54[] = { "Object"};
00542 static char* errors_54[] = {NULL};
00543 static primitive_desc primitive_54 = {
00544 "primitiveClearInvocationCounters",
00545 fntype(&debugPrimitives::clearInvocationCounters),
00546 65536,
00547 signature_54,
00548 errors_54
00549 };
00550
00551 static char* signature_55[] = { "Object"};
00552 static char* errors_55[] = {NULL};
00553 static primitive_desc primitive_55 = {
00554 "primitiveClearLookupCache",
00555 fntype(&debugPrimitives::clearLookupCache),
00556 65536,
00557 signature_55,
00558 errors_55
00559 };
00560
00561 static char* signature_56[] = { "Object"};
00562 static char* errors_56[] = {NULL};
00563 static primitive_desc primitive_56 = {
00564 "primitiveClearLookupCacheStatistics",
00565 fntype(&debugPrimitives::clearLookupCacheStatistics),
00566 65536,
00567 signature_56,
00568 errors_56
00569 };
00570
00571 static char* signature_57[] = { "Object"};
00572 static char* errors_57[] = {NULL};
00573 static primitive_desc primitive_57 = {
00574 "primitiveClearNMethodCounters",
00575 fntype(&debugPrimitives::clearNMethodCounters),
00576 65536,
00577 signature_57,
00578 errors_57
00579 };
00580
00581 static char* signature_58[] = { "Object"};
00582 static char* errors_58[] = {NULL};
00583 static primitive_desc primitive_58 = {
00584 "primitiveClearPrimitiveCounters",
00585 fntype(&debugPrimitives::clearPrimitiveCounters),
00586 65536,
00587 signature_58,
00588 errors_58
00589 };
00590
00591 static char* signature_59[] = { "Block"};
00592 static char* errors_59[] = {NULL};
00593 static primitive_desc primitive_59 = {
00594 "primitiveCompiledBlockAllocate0",
00595 fntype(&allocateBlock0),
00596 6359040,
00597 signature_59,
00598 errors_59
00599 };
00600
00601 static char* signature_60[] = { "Block"};
00602 static char* errors_60[] = {NULL};
00603 static primitive_desc primitive_60 = {
00604 "primitiveCompiledBlockAllocate1",
00605 fntype(&allocateBlock1),
00606 6359040,
00607 signature_60,
00608 errors_60
00609 };
00610
00611 static char* signature_61[] = { "Block"};
00612 static char* errors_61[] = {NULL};
00613 static primitive_desc primitive_61 = {
00614 "primitiveCompiledBlockAllocate2",
00615 fntype(&allocateBlock2),
00616 6359040,
00617 signature_61,
00618 errors_61
00619 };
00620
00621 static char* signature_62[] = { "Block"};
00622 static char* errors_62[] = {NULL};
00623 static primitive_desc primitive_62 = {
00624 "primitiveCompiledBlockAllocate3",
00625 fntype(&allocateBlock3),
00626 6359040,
00627 signature_62,
00628 errors_62
00629 };
00630
00631 static char* signature_63[] = { "Block"};
00632 static char* errors_63[] = {NULL};
00633 static primitive_desc primitive_63 = {
00634 "primitiveCompiledBlockAllocate4",
00635 fntype(&allocateBlock4),
00636 6359040,
00637 signature_63,
00638 errors_63
00639 };
00640
00641 static char* signature_64[] = { "Block"};
00642 static char* errors_64[] = {NULL};
00643 static primitive_desc primitive_64 = {
00644 "primitiveCompiledBlockAllocate5",
00645 fntype(&allocateBlock5),
00646 6359040,
00647 signature_64,
00648 errors_64
00649 };
00650
00651 static char* signature_65[] = { "Block"};
00652 static char* errors_65[] = {NULL};
00653 static primitive_desc primitive_65 = {
00654 "primitiveCompiledBlockAllocate6",
00655 fntype(&allocateBlock6),
00656 6359040,
00657 signature_65,
00658 errors_65
00659 };
00660
00661 static char* signature_66[] = { "Block"};
00662 static char* errors_66[] = {NULL};
00663 static primitive_desc primitive_66 = {
00664 "primitiveCompiledBlockAllocate7",
00665 fntype(&allocateBlock7),
00666 6359040,
00667 signature_66,
00668 errors_66
00669 };
00670
00671 static char* signature_67[] = { "Block"};
00672 static char* errors_67[] = {NULL};
00673 static primitive_desc primitive_67 = {
00674 "primitiveCompiledBlockAllocate8",
00675 fntype(&allocateBlock8),
00676 6359040,
00677 signature_67,
00678 errors_67
00679 };
00680
00681 static char* signature_68[] = { "Block"};
00682 static char* errors_68[] = {NULL};
00683 static primitive_desc primitive_68 = {
00684 "primitiveCompiledBlockAllocate9",
00685 fntype(&allocateBlock9),
00686 6359040,
00687 signature_68,
00688 errors_68
00689 };
00690
00691 static char* signature_69[] = { "Block", "SmallInteger"};
00692 static char* errors_69[] = {NULL};
00693 static primitive_desc primitive_69 = {
00694 "primitiveCompiledBlockAllocate:",
00695 fntype(&allocateBlock),
00696 2164737,
00697 signature_69,
00698 errors_69
00699 };
00700
00701 static char* signature_70[] = { "Object"};
00702 static char* errors_70[] = {NULL};
00703 static primitive_desc primitive_70 = {
00704 "primitiveCompiledContextAllocate0",
00705 fntype(&allocateContext0),
00706 6359040,
00707 signature_70,
00708 errors_70
00709 };
00710
00711 static char* signature_71[] = { "Object"};
00712 static char* errors_71[] = {NULL};
00713 static primitive_desc primitive_71 = {
00714 "primitiveCompiledContextAllocate1",
00715 fntype(&allocateContext1),
00716 6359040,
00717 signature_71,
00718 errors_71
00719 };
00720
00721 static char* signature_72[] = { "Object"};
00722 static char* errors_72[] = {NULL};
00723 static primitive_desc primitive_72 = {
00724 "primitiveCompiledContextAllocate2",
00725 fntype(&allocateContext2),
00726 6359040,
00727 signature_72,
00728 errors_72
00729 };
00730
00731 static char* signature_73[] = { "Object", "SmallInteger"};
00732 static char* errors_73[] = {NULL};
00733 static primitive_desc primitive_73 = {
00734 "primitiveCompiledContextAllocate:",
00735 fntype(&allocateContext),
00736 6359041,
00737 signature_73,
00738 errors_73
00739 };
00740
00741 static char* signature_74[] = { "Method", "Object", "SmallInteger", "SmallInteger", "Array", "ByteArray", "Array"};
00742 static char* errors_74[] = {NULL};
00743 static primitive_desc primitive_74 = {
00744 "primitiveConstructMethod:flags:nofArgs:debugInfo:bytes:oops:ifFail:",
00745 fntype(&methodOopPrimitives::constructMethod),
00746 327686,
00747 signature_74,
00748 errors_74
00749 };
00750
00751 static char* signature_75[] = { "Object", "Object"};
00752 static char* errors_75[] = { "NotOops", NULL};
00753 static primitive_desc primitive_75 = {
00754 "primitiveCopyTenuredIfFail:",
00755 fntype(&oopPrimitives::copy_tenured),
00756 1376257,
00757 signature_75,
00758 errors_75
00759 };
00760
00761 static char* signature_76[] = { "GlobalAssociation", "Mixin", "Symbol", "Boolean", "Behavior", "Symbol"};
00762 static char* errors_76[] = { "WrongFormat", NULL};
00763 static primitive_desc primitive_76 = {
00764 "primitiveCreateInvocationOf:named:isPrimaryInvocation:superclass:format:ifFail:",
00765 fntype(&systemPrimitives::createNamedInvocation),
00766 327685,
00767 signature_76,
00768 errors_76
00769 };
00770
00771 static char* signature_77[] = { "GlobalAssociation", "Mixin", "Behavior", "Symbol"};
00772 static char* errors_77[] = { "WrongFormat", NULL};
00773 static primitive_desc primitive_77 = {
00774 "primitiveCreateInvocationOf:superclass:format:ifFail:",
00775 fntype(&systemPrimitives::createInvocation),
00776 327683,
00777 signature_77,
00778 errors_77
00779 };
00780
00781 static char* signature_78[] = { "Proxy", "Symbol", "Proxy"};
00782 static char* errors_78[] = {NULL};
00783 static primitive_desc primitive_78 = {
00784 "primitiveDLLLoad:result:ifFail:",
00785 fntype(&systemPrimitives::dll_load),
00786 327682,
00787 signature_78,
00788 errors_78
00789 };
00790
00791 static char* signature_79[] = { "Proxy", "Symbol", "Proxy", "Proxy"};
00792 static char* errors_79[] = {NULL};
00793 static primitive_desc primitive_79 = {
00794 "primitiveDLLLookup:in:result:ifFail:",
00795 fntype(&systemPrimitives::dll_lookup),
00796 327683,
00797 signature_79,
00798 errors_79
00799 };
00800
00801 static char* signature_80[] = { "Object", "Object", "Symbol"};
00802 static char* errors_80[] = {NULL};
00803 static primitive_desc primitive_80 = {
00804 "primitiveDLLSetupLookup:selector:ifFail:",
00805 fntype(&systemPrimitives::dll_setup),
00806 327682,
00807 signature_80,
00808 errors_80
00809 };
00810
00811 static char* signature_81[] = { "Object", "Proxy"};
00812 static char* errors_81[] = {NULL};
00813 static primitive_desc primitive_81 = {
00814 "primitiveDLLUnload:ifFail:",
00815 fntype(&systemPrimitives::dll_unload),
00816 327681,
00817 signature_81,
00818 errors_81
00819 };
00820
00821 static char* signature_82[] = { "Object"};
00822 static char* errors_82[] = {NULL};
00823 static primitive_desc primitive_82 = {
00824 "primitiveDecodeAllMethods",
00825 fntype(&debugPrimitives::decodeAllMethods),
00826 65536,
00827 signature_82,
00828 errors_82
00829 };
00830
00831 static char* signature_83[] = { "Object", "Object", "Symbol"};
00832 static char* errors_83[] = { "NotFound", NULL};
00833 static primitive_desc primitive_83 = {
00834 "primitiveDecodeMethod:ifFail:",
00835 fntype(&debugPrimitives::decodeMethod),
00836 1376258,
00837 signature_83,
00838 errors_83
00839 };
00840
00841 static char* signature_84[] = { "Proxy", "Proxy"};
00842 static char* errors_84[] = {NULL};
00843 static primitive_desc primitive_84 = {
00844 "primitiveDefWindowProc:ifFail:",
00845 fntype(&systemPrimitives::defWindowProc),
00846 327681,
00847 signature_84,
00848 errors_84
00849 };
00850
00851 static char* signature_85[] = { "Object"};
00852 static char* errors_85[] = {NULL};
00853 static primitive_desc primitive_85 = {
00854 "primitiveDeoptimizeStacks",
00855 fntype(&debugPrimitives::deoptimizeStacks),
00856 196608,
00857 signature_85,
00858 errors_85
00859 };
00860
00861 static char* signature_86[] = { "SmallInteger", "SmallInteger", "SmallInteger"};
00862 static char* errors_86[] = { "Overflow", "DivisionByZero", NULL};
00863 static primitive_desc primitive_86 = {
00864 "primitiveDiv:ifFail:",
00865 fntype(&smiOopPrimitives_div),
00866 6029826,
00867 signature_86,
00868 errors_86
00869 };
00870
00871 static char* signature_87[] = { "Float"};
00872 static char* errors_87[] = {NULL};
00873 static primitive_desc primitive_87 = {
00874 "primitiveElapsedTime",
00875 fntype(&systemPrimitives::elapsedTime),
00876 65536,
00877 signature_87,
00878 errors_87
00879 };
00880
00881 static char* signature_88[] = { "Boolean", "Object", "Object"};
00882 static char* errors_88[] = {NULL};
00883 static primitive_desc primitive_88 = {
00884 "primitiveEqual:",
00885 fntype(&oopPrimitives::equal),
00886 1572866,
00887 signature_88,
00888 errors_88
00889 };
00890
00891 static char* signature_89[] = { "Process|nil"};
00892 static char* errors_89[] = {NULL};
00893 static primitive_desc primitive_89 = {
00894 "primitiveFlatProfilerDisengage",
00895 fntype(&systemPrimitives::flat_profiler_disengage),
00896 65536,
00897 signature_89,
00898 errors_89
00899 };
00900
00901 static char* signature_90[] = { "Process", "Process"};
00902 static char* errors_90[] = {NULL};
00903 static primitive_desc primitive_90 = {
00904 "primitiveFlatProfilerEngage:ifFail:",
00905 fntype(&systemPrimitives::flat_profiler_engage),
00906 327681,
00907 signature_90,
00908 errors_90
00909 };
00910
00911 static char* signature_91[] = { "Object"};
00912 static char* errors_91[] = {NULL};
00913 static primitive_desc primitive_91 = {
00914 "primitiveFlatProfilerPrint",
00915 fntype(&systemPrimitives::flat_profiler_print),
00916 65536,
00917 signature_91,
00918 errors_91
00919 };
00920
00921 static char* signature_92[] = { "Process|nil"};
00922 static char* errors_92[] = {NULL};
00923 static primitive_desc primitive_92 = {
00924 "primitiveFlatProfilerProcess",
00925 fntype(&systemPrimitives::flat_profiler_process),
00926 65536,
00927 signature_92,
00928 errors_92
00929 };
00930
00931 static char* signature_93[] = { "Object"};
00932 static char* errors_93[] = {NULL};
00933 static primitive_desc primitive_93 = {
00934 "primitiveFlatProfilerReset",
00935 fntype(&systemPrimitives::flat_profiler_reset),
00936 65536,
00937 signature_93,
00938 errors_93
00939 };
00940
00941 static char* signature_94[] = { "Float", "Float", "Float"};
00942 static char* errors_94[] = {NULL};
00943 static primitive_desc primitive_94 = {
00944 "primitiveFloatAdd:ifFail:",
00945 fntype(&double_add),
00946 6030338,
00947 signature_94,
00948 errors_94
00949 };
00950
00951 static char* signature_95[] = { "Float", "Float"};
00952 static char* errors_95[] = {NULL};
00953 static primitive_desc primitive_95 = {
00954 "primitiveFloatArcCosineIfFail:",
00955 fntype(&doubleOopPrimitives::arcCosine),
00956 1836033,
00957 signature_95,
00958 errors_95
00959 };
00960
00961 static char* signature_96[] = { "Float", "Float"};
00962 static char* errors_96[] = {NULL};
00963 static primitive_desc primitive_96 = {
00964 "primitiveFloatArcSineIfFail:",
00965 fntype(&doubleOopPrimitives::arcSine),
00966 1836033,
00967 signature_96,
00968 errors_96
00969 };
00970
00971 static char* signature_97[] = { "Float", "Float"};
00972 static char* errors_97[] = {NULL};
00973 static primitive_desc primitive_97 = {
00974 "primitiveFloatArcTangentIfFail:",
00975 fntype(&doubleOopPrimitives::arcTangent),
00976 1836033,
00977 signature_97,
00978 errors_97
00979 };
00980
00981 static char* signature_98[] = { "SmallInteger", "Float"};
00982 static char* errors_98[] = { "SmallIntegerConversionFailed", NULL};
00983 static primitive_desc primitive_98 = {
00984 "primitiveFloatAsSmallIntegerIfFail:",
00985 fntype(&doubleOopPrimitives::asSmallInteger),
00986 1836033,
00987 signature_98,
00988 errors_98
00989 };
00990
00991 static char* signature_99[] = { "Float", "Float"};
00992 static char* errors_99[] = {NULL};
00993 static primitive_desc primitive_99 = {
00994 "primitiveFloatCeiling",
00995 fntype(&doubleOopPrimitives::ceiling),
00996 1573889,
00997 signature_99,
00998 errors_99
00999 };
01000
01001 static char* signature_100[] = { "Float", "Float"};
01002 static char* errors_100[] = {NULL};
01003 static primitive_desc primitive_100 = {
01004 "primitiveFloatCosine",
01005 fntype(&doubleOopPrimitives::cosine),
01006 1573889,
01007 signature_100,
01008 errors_100
01009 };
01010
01011 static char* signature_101[] = { "Float", "Float", "Float"};
01012 static char* errors_101[] = {NULL};
01013 static primitive_desc primitive_101 = {
01014 "primitiveFloatDivide:ifFail:",
01015 fntype(&double_divide),
01016 6030338,
01017 signature_101,
01018 errors_101
01019 };
01020
01021 static char* signature_102[] = { "Boolean", "Float", "Float"};
01022 static char* errors_102[] = {NULL};
01023 static primitive_desc primitive_102 = {
01024 "primitiveFloatEqual:ifFail:",
01025 fntype(&doubleOopPrimitives::equal),
01026 6030082,
01027 signature_102,
01028 errors_102
01029 };
01030
01031 static char* signature_103[] = { "Float", "Float"};
01032 static char* errors_103[] = {NULL};
01033 static primitive_desc primitive_103 = {
01034 "primitiveFloatExp",
01035 fntype(&doubleOopPrimitives::exp),
01036 1573889,
01037 signature_103,
01038 errors_103
01039 };
01040
01041 static char* signature_104[] = { "SmallInteger", "Float"};
01042 static char* errors_104[] = {NULL};
01043 static primitive_desc primitive_104 = {
01044 "primitiveFloatExponent",
01045 fntype(&doubleOopPrimitives::exponent),
01046 1573889,
01047 signature_104,
01048 errors_104
01049 };
01050
01051 static char* signature_105[] = { "Float", "Float"};
01052 static char* errors_105[] = {NULL};
01053 static primitive_desc primitive_105 = {
01054 "primitiveFloatFloor",
01055 fntype(&doubleOopPrimitives::floor),
01056 1573889,
01057 signature_105,
01058 errors_105
01059 };
01060
01061 static char* signature_106[] = { "Boolean", "Float", "Float"};
01062 static char* errors_106[] = {NULL};
01063 static primitive_desc primitive_106 = {
01064 "primitiveFloatGreaterThan:ifFail:",
01065 fntype(&doubleOopPrimitives::greaterThan),
01066 6030082,
01067 signature_106,
01068 errors_106
01069 };
01070
01071 static char* signature_107[] = { "Boolean", "Float", "Float"};
01072 static char* errors_107[] = {NULL};
01073 static primitive_desc primitive_107 = {
01074 "primitiveFloatGreaterThanOrEqual:ifFail:",
01075 fntype(&doubleOopPrimitives::greaterThanOrEqual),
01076 6030082,
01077 signature_107,
01078 errors_107
01079 };
01080
01081 static char* signature_108[] = { "Float", "Float"};
01082 static char* errors_108[] = {NULL};
01083 static primitive_desc primitive_108 = {
01084 "primitiveFloatHyperbolicCosineIfFail:",
01085 fntype(&doubleOopPrimitives::hyperbolicCosine),
01086 1836033,
01087 signature_108,
01088 errors_108
01089 };
01090
01091 static char* signature_109[] = { "Float", "Float"};
01092 static char* errors_109[] = {NULL};
01093 static primitive_desc primitive_109 = {
01094 "primitiveFloatHyperbolicSineIfFail:",
01095 fntype(&doubleOopPrimitives::hyperbolicSine),
01096 1836033,
01097 signature_109,
01098 errors_109
01099 };
01100
01101 static char* signature_110[] = { "Float", "Float"};
01102 static char* errors_110[] = {NULL};
01103 static primitive_desc primitive_110 = {
01104 "primitiveFloatHyperbolicTangentIfFail:",
01105 fntype(&doubleOopPrimitives::hyperbolicTangent),
01106 1836033,
01107 signature_110,
01108 errors_110
01109 };
01110
01111 static char* signature_111[] = { "Boolean", "Float"};
01112 static char* errors_111[] = {NULL};
01113 static primitive_desc primitive_111 = {
01114 "primitiveFloatIsFinite",
01115 fntype(&doubleOopPrimitives::isFinite),
01116 1573889,
01117 signature_111,
01118 errors_111
01119 };
01120
01121 static char* signature_112[] = { "Boolean", "Float"};
01122 static char* errors_112[] = {NULL};
01123 static primitive_desc primitive_112 = {
01124 "primitiveFloatIsNan",
01125 fntype(&doubleOopPrimitives::isNan),
01126 1573889,
01127 signature_112,
01128 errors_112
01129 };
01130
01131 static char* signature_113[] = { "Boolean", "Float", "Float"};
01132 static char* errors_113[] = {NULL};
01133 static primitive_desc primitive_113 = {
01134 "primitiveFloatLessThan:ifFail:",
01135 fntype(&doubleOopPrimitives::lessThan),
01136 6030082,
01137 signature_113,
01138 errors_113
01139 };
01140
01141 static char* signature_114[] = { "Boolean", "Float", "Float"};
01142 static char* errors_114[] = {NULL};
01143 static primitive_desc primitive_114 = {
01144 "primitiveFloatLessThanOrEqual:ifFail:",
01145 fntype(&doubleOopPrimitives::lessThanOrEqual),
01146 6030082,
01147 signature_114,
01148 errors_114
01149 };
01150
01151 static char* signature_115[] = { "Float", "Float"};
01152 static char* errors_115[] = { "ReceiverNotStrictlyPositive", NULL};
01153 static primitive_desc primitive_115 = {
01154 "primitiveFloatLnIfFail:",
01155 fntype(&doubleOopPrimitives::ln),
01156 1836033,
01157 signature_115,
01158 errors_115
01159 };
01160
01161 static char* signature_116[] = { "Float", "Float"};
01162 static char* errors_116[] = { "ReceiverNotStrictlyPositive", NULL};
01163 static primitive_desc primitive_116 = {
01164 "primitiveFloatLog10IfFail:",
01165 fntype(&doubleOopPrimitives::log10),
01166 1836033,
01167 signature_116,
01168 errors_116
01169 };
01170
01171 static char* signature_117[] = { "Float", "Float"};
01172 static char* errors_117[] = {NULL};
01173 static primitive_desc primitive_117 = {
01174 "primitiveFloatMantissa",
01175 fntype(&doubleOopPrimitives::mantissa),
01176 1573889,
01177 signature_117,
01178 errors_117
01179 };
01180
01181 static char* signature_118[] = { "Float"};
01182 static char* errors_118[] = {NULL};
01183 static primitive_desc primitive_118 = {
01184 "primitiveFloatMaxValue",
01185 fntype(&doubleOopPrimitives::min_positive_value),
01186 524288,
01187 signature_118,
01188 errors_118
01189 };
01190
01191 static char* signature_119[] = { "Float"};
01192 static char* errors_119[] = {NULL};
01193 static primitive_desc primitive_119 = {
01194 "primitiveFloatMinPositiveValue",
01195 fntype(&doubleOopPrimitives::min_positive_value),
01196 524288,
01197 signature_119,
01198 errors_119
01199 };
01200
01201 static char* signature_120[] = { "Float", "Float", "Float"};
01202 static char* errors_120[] = {NULL};
01203 static primitive_desc primitive_120 = {
01204 "primitiveFloatMod:ifFail:",
01205 fntype(&doubleOopPrimitives::mod),
01206 1836034,
01207 signature_120,
01208 errors_120
01209 };
01210
01211 static char* signature_121[] = { "Float", "Float", "Float"};
01212 static char* errors_121[] = {NULL};
01213 static primitive_desc primitive_121 = {
01214 "primitiveFloatMultiply:ifFail:",
01215 fntype(&double_multiply),
01216 6030338,
01217 signature_121,
01218 errors_121
01219 };
01220
01221 static char* signature_122[] = { "Boolean", "Float", "Float"};
01222 static char* errors_122[] = {NULL};
01223 static primitive_desc primitive_122 = {
01224 "primitiveFloatNotEqual:ifFail:",
01225 fntype(&doubleOopPrimitives::notEqual),
01226 6030082,
01227 signature_122,
01228 errors_122
01229 };
01230
01231 static char* signature_123[] = { "Self", "Float", "IndexedByteInstanceVariables"};
01232 static char* errors_123[] = {NULL};
01233 static primitive_desc primitive_123 = {
01234 "primitiveFloatPrintFormat:ifFail:",
01235 fntype(&doubleOopPrimitives::printFormat),
01236 1310722,
01237 signature_123,
01238 errors_123
01239 };
01240
01241 static char* signature_124[] = { "IndexedByteInstanceVariables", "Float"};
01242 static char* errors_124[] = {NULL};
01243 static primitive_desc primitive_124 = {
01244 "primitiveFloatPrintString",
01245 fntype(&doubleOopPrimitives::printString),
01246 1048577,
01247 signature_124,
01248 errors_124
01249 };
01250
01251 static char* signature_125[] = { "SmallInteger", "Float"};
01252 static char* errors_125[] = { "SmallIntegerConversionFailed", NULL};
01253 static primitive_desc primitive_125 = {
01254 "primitiveFloatRoundedAsSmallIntegerIfFail:",
01255 fntype(&doubleOopPrimitives::roundedAsSmallInteger),
01256 1836033,
01257 signature_125,
01258 errors_125
01259 };
01260
01261 static char* signature_126[] = { "Float", "Float"};
01262 static char* errors_126[] = {NULL};
01263 static primitive_desc primitive_126 = {
01264 "primitiveFloatSine",
01265 fntype(&doubleOopPrimitives::sine),
01266 1573889,
01267 signature_126,
01268 errors_126
01269 };
01270
01271 static char* signature_127[] = { "SmallInteger", "Float"};
01272 static char* errors_127[] = { "ConversionFailed", NULL};
01273 static primitive_desc primitive_127 = {
01274 "primitiveFloatSmallIntegerFloorIfFail:",
01275 fntype(&doubleOopPrimitives::smi_floor),
01276 6030337,
01277 signature_127,
01278 errors_127
01279 };
01280
01281 static char* signature_128[] = { "Float", "Float"};
01282 static char* errors_128[] = { "ReceiverNegative", NULL};
01283 static primitive_desc primitive_128 = {
01284 "primitiveFloatSqrtIfFail:",
01285 fntype(&doubleOopPrimitives::sqrt),
01286 1836033,
01287 signature_128,
01288 errors_128
01289 };
01290
01291 static char* signature_129[] = { "Float", "Float"};
01292 static char* errors_129[] = {NULL};
01293 static primitive_desc primitive_129 = {
01294 "primitiveFloatSquared",
01295 fntype(&doubleOopPrimitives::squared),
01296 1573889,
01297 signature_129,
01298 errors_129
01299 };
01300
01301 static char* signature_130[] = { "ByteArray", "Float"};
01302 static char* errors_130[] = {NULL};
01303 static primitive_desc primitive_130 = {
01304 "primitiveFloatStoreString",
01305 fntype(&doubleOopPrimitives::store_string),
01306 1048577,
01307 signature_130,
01308 errors_130
01309 };
01310
01311 static char* signature_131[] = { "Float", "Float", "Float"};
01312 static char* errors_131[] = {NULL};
01313 static primitive_desc primitive_131 = {
01314 "primitiveFloatSubtract:ifFail:",
01315 fntype(&double_subtract),
01316 6030338,
01317 signature_131,
01318 errors_131
01319 };
01320
01321 static char* signature_132[] = { "Float", "Float"};
01322 static char* errors_132[] = {NULL};
01323 static primitive_desc primitive_132 = {
01324 "primitiveFloatTangentIfFail:",
01325 fntype(&doubleOopPrimitives::tangent),
01326 1836033,
01327 signature_132,
01328 errors_132
01329 };
01330
01331 static char* signature_133[] = { "Float", "Float", "SmallInteger"};
01332 static char* errors_133[] = { "RangeError", NULL};
01333 static primitive_desc primitive_133 = {
01334 "primitiveFloatTimesTwoPower:ifFail:",
01335 fntype(&doubleOopPrimitives::timesTwoPower),
01336 1836034,
01337 signature_133,
01338 errors_133
01339 };
01340
01341 static char* signature_134[] = { "Float", "Float"};
01342 static char* errors_134[] = {NULL};
01343 static primitive_desc primitive_134 = {
01344 "primitiveFloatTruncated",
01345 fntype(&doubleOopPrimitives::truncated),
01346 1573889,
01347 signature_134,
01348 errors_134
01349 };
01350
01351 static char* signature_135[] = { "Object"};
01352 static char* errors_135[] = {NULL};
01353 static primitive_desc primitive_135 = {
01354 "primitiveFlushCodeCache",
01355 fntype(&systemPrimitives::flush_code_cache),
01356 65536,
01357 signature_135,
01358 errors_135
01359 };
01360
01361 static char* signature_136[] = { "Object"};
01362 static char* errors_136[] = {NULL};
01363 static primitive_desc primitive_136 = {
01364 "primitiveFlushDeadCode",
01365 fntype(&systemPrimitives::flush_dead_code),
01366 65536,
01367 signature_136,
01368 errors_136
01369 };
01370
01371 static char* signature_137[] = { "Self", "Object"};
01372 static char* errors_137[] = {NULL};
01373 static primitive_desc primitive_137 = {
01374 "primitiveGarbageCollect",
01375 fntype(&systemPrimitives::garbageGollect),
01376 1114113,
01377 signature_137,
01378 errors_137
01379 };
01380
01381 static char* signature_138[] = { "Object", "Object", "Symbol"};
01382 static char* errors_138[] = { "NotFound", NULL};
01383 static primitive_desc primitive_138 = {
01384 "primitiveGenerateIR:ifFail:",
01385 fntype(&debugPrimitives::generateIR),
01386 1376258,
01387 signature_138,
01388 errors_138
01389 };
01390
01391 static char* signature_139[] = { "Boolean", "GlobalAssociation"};
01392 static char* errors_139[] = {NULL};
01393 static primitive_desc primitive_139 = {
01394 "primitiveGlobalAssociationIsConstant",
01395 fntype(&systemPrimitives::globalAssociationIsConstant),
01396 1114113,
01397 signature_139,
01398 errors_139
01399 };
01400
01401 static char* signature_140[] = { "Symbol", "GlobalAssociation"};
01402 static char* errors_140[] = {NULL};
01403 static primitive_desc primitive_140 = {
01404 "primitiveGlobalAssociationKey",
01405 fntype(&systemPrimitives::globalAssociationKey),
01406 1114113,
01407 signature_140,
01408 errors_140
01409 };
01410
01411 static char* signature_141[] = { "Boolean", "GlobalAssociation", "Boolean"};
01412 static char* errors_141[] = {NULL};
01413 static primitive_desc primitive_141 = {
01414 "primitiveGlobalAssociationSetConstant:",
01415 fntype(&systemPrimitives::globalAssociationSetConstant),
01416 1114114,
01417 signature_141,
01418 errors_141
01419 };
01420
01421 static char* signature_142[] = { "Object", "GlobalAssociation", "Symbol"};
01422 static char* errors_142[] = {NULL};
01423 static primitive_desc primitive_142 = {
01424 "primitiveGlobalAssociationSetKey:",
01425 fntype(&systemPrimitives::globalAssociationSetKey),
01426 1114114,
01427 signature_142,
01428 errors_142
01429 };
01430
01431 static char* signature_143[] = { "Object", "GlobalAssociation", "Object"};
01432 static char* errors_143[] = {NULL};
01433 static primitive_desc primitive_143 = {
01434 "primitiveGlobalAssociationSetValue:",
01435 fntype(&systemPrimitives::globalAssociationSetValue),
01436 1114114,
01437 signature_143,
01438 errors_143
01439 };
01440
01441 static char* signature_144[] = { "Object", "GlobalAssociation"};
01442 static char* errors_144[] = {NULL};
01443 static primitive_desc primitive_144 = {
01444 "primitiveGlobalAssociationValue",
01445 fntype(&systemPrimitives::globalAssociationValue),
01446 1114113,
01447 signature_144,
01448 errors_144
01449 };
01450
01451 static char* signature_145[] = { "Boolean", "SmallInteger", "SmallInteger"};
01452 static char* errors_145[] = {NULL};
01453 static primitive_desc primitive_145 = {
01454 "primitiveGreaterThan:ifFail:",
01455 fntype(&smiOopPrimitives::greaterThan),
01456 6029570,
01457 signature_145,
01458 errors_145
01459 };
01460
01461 static char* signature_146[] = { "Boolean", "SmallInteger", "SmallInteger"};
01462 static char* errors_146[] = {NULL};
01463 static primitive_desc primitive_146 = {
01464 "primitiveGreaterThanOrEqual:ifFail:",
01465 fntype(&smiOopPrimitives::greaterThanOrEqual),
01466 6029570,
01467 signature_146,
01468 errors_146
01469 };
01470
01471 static char* signature_147[] = { "Boolean", "Object"};
01472 static char* errors_147[] = {NULL};
01473 static primitive_desc primitive_147 = {
01474 "primitiveHadNearDeathExperience:",
01475 fntype(&systemPrimitives::hadNearDeathExperience),
01476 65537,
01477 signature_147,
01478 errors_147
01479 };
01480
01481 static char* signature_148[] = { "Object"};
01482 static char* errors_148[] = {NULL};
01483 static primitive_desc primitive_148 = {
01484 "primitiveHalt",
01485 fntype(&systemPrimitives::halt),
01486 65536,
01487 signature_148,
01488 errors_148
01489 };
01490
01491 static char* signature_149[] = { "SmallInteger", "Object"};
01492 static char* errors_149[] = {NULL};
01493 static primitive_desc primitive_149 = {
01494 "primitiveHash",
01495 fntype(&oopPrimitives::hash),
01496 1114113,
01497 signature_149,
01498 errors_149
01499 };
01500
01501 static char* signature_150[] = { "SmallInteger", "Object"};
01502 static char* errors_150[] = {NULL};
01503 static primitive_desc primitive_150 = {
01504 "primitiveHashOf:",
01505 fntype(&oopPrimitives::hash_of),
01506 65537,
01507 signature_150,
01508 errors_150
01509 };
01510
01511 static char* signature_151[] = { "SmallInteger", "IndexedByteInstanceVariables", "SmallInteger"};
01512 static char* errors_151[] = { "OutOfBounds", NULL};
01513 static primitive_desc primitive_151 = {
01514 "primitiveIndexedByteAt:ifFail:",
01515 fntype(&byteArrayPrimitives::at),
01516 1312258,
01517 signature_151,
01518 errors_151
01519 };
01520
01521 static char* signature_152[] = { "SmallInteger", "IndexedByteInstanceVariables", "SmallInteger", "SmallInteger"};
01522 static char* errors_152[] = { "OutOfBounds", "ValueOutOfBounds", NULL};
01523 static primitive_desc primitive_152 = {
01524 "primitiveIndexedByteAt:put:ifFail:",
01525 fntype(&byteArrayPrimitives::atPut),
01526 1312259,
01527 signature_152,
01528 errors_152
01529 };
01530
01531 static char* signature_153[] = { "Self", "IndexedByteInstanceVariables", "SmallInteger"};
01532 static char* errors_153[] = {NULL};
01533 static primitive_desc primitive_153 = {
01534 "primitiveIndexedByteAtAllPut:ifFail:",
01535 fntype(&byteArrayPrimitives::at_all_put),
01536 1376258,
01537 signature_153,
01538 errors_153
01539 };
01540
01541 static char* signature_154[] = { "SmallInteger", "IndexedByteInstanceVariables", "SmallInteger"};
01542 static char* errors_154[] = { "OutOfBounds", NULL};
01543 static primitive_desc primitive_154 = {
01544 "primitiveIndexedByteCharacterAt:ifFail:",
01545 fntype(&byteArrayPrimitives::characterAt),
01546 1312258,
01547 signature_154,
01548 errors_154
01549 };
01550
01551 static char* signature_155[] = { "SmallInteger", "IndexedByteInstanceVariables", "String"};
01552 static char* errors_155[] = {NULL};
01553 static primitive_desc primitive_155 = {
01554 "primitiveIndexedByteCompare:ifFail:",
01555 fntype(&byteArrayPrimitives::compare),
01556 1376258,
01557 signature_155,
01558 errors_155
01559 };
01560
01561 static char* signature_156[] = { "SmallInteger", "IndexedByteInstanceVariables"};
01562 static char* errors_156[] = {NULL};
01563 static primitive_desc primitive_156 = {
01564 "primitiveIndexedByteHash",
01565 fntype(&byteArrayPrimitives::hash),
01566 1574401,
01567 signature_156,
01568 errors_156
01569 };
01570
01571 static char* signature_157[] = { "CompressedSymbol", "IndexedByteInstanceVariables"};
01572 static char* errors_157[] = { "ValueOutOfBounds", NULL};
01573 static primitive_desc primitive_157 = {
01574 "primitiveIndexedByteInternIfFail:",
01575 fntype(&byteArrayPrimitives::intern),
01576 1376257,
01577 signature_157,
01578 errors_157
01579 };
01580
01581 static char* signature_158[] = { "IndexedByteInstanceVariables|SmallInteger", "IndexedByteInstanceVariables", "IndexedByteInstanceVariables"};
01582 static char* errors_158[] = { "ArgumentIsInvalid", NULL};
01583 static primitive_desc primitive_158 = {
01584 "primitiveIndexedByteLargeIntegerAdd:ifFail:",
01585 fntype(&byteArrayPrimitives::largeIntegerAdd),
01586 1312258,
01587 signature_158,
01588 errors_158
01589 };
01590
01591 static char* signature_159[] = { "Float", "IndexedByteInstanceVariables"};
01592 static char* errors_159[] = {NULL};
01593 static primitive_desc primitive_159 = {
01594 "primitiveIndexedByteLargeIntegerAsFloatIfFail:",
01595 fntype(&byteArrayPrimitives::largeIntegerToFloat),
01596 1312257,
01597 signature_159,
01598 errors_159
01599 };
01600
01601 static char* signature_160[] = { "SmallInteger", "IndexedByteInstanceVariables", "IndexedByteInstanceVariables"};
01602 static char* errors_160[] = {NULL};
01603 static primitive_desc primitive_160 = {
01604 "primitiveIndexedByteLargeIntegerCompare:ifFail:",
01605 fntype(&byteArrayPrimitives::largeIntegerCompare),
01606 1312258,
01607 signature_160,
01608 errors_160
01609 };
01610
01611 static char* signature_161[] = { "IndexedByteInstanceVariables|SmallInteger", "IndexedByteInstanceVariables", "IndexedByteInstanceVariables"};
01612 static char* errors_161[] = { "ArgumentIsInvalid", "DivisionByZero", NULL};
01613 static primitive_desc primitive_161 = {
01614 "primitiveIndexedByteLargeIntegerDiv:ifFail:",
01615 fntype(&byteArrayPrimitives::largeIntegerDiv),
01616 1312258,
01617 signature_161,
01618 errors_161
01619 };
01620
01621 static char* signature_162[] = { "IndexedByteInstanceVariables", "IndexedByteInstanceVariables class", "Float"};
01622 static char* errors_162[] = {NULL};
01623 static primitive_desc primitive_162 = {
01624 "primitiveIndexedByteLargeIntegerFromFloat:ifFail:",
01625 fntype(&byteArrayPrimitives::largeIntegerFromDouble),
01626 1310722,
01627 signature_162,
01628 errors_162
01629 };
01630
01631 static char* signature_163[] = { "IndexedByteInstanceVariables", "IndexedByteInstanceVariables class", "SmallInteger"};
01632 static char* errors_163[] = {NULL};
01633 static primitive_desc primitive_163 = {
01634 "primitiveIndexedByteLargeIntegerFromSmallInteger:ifFail:",
01635 fntype(&byteArrayPrimitives::largeIntegerFromSmallInteger),
01636 1310722,
01637 signature_163,
01638 errors_163
01639 };
01640
01641 static char* signature_164[] = { "IndexedByteInstanceVariables", "IndexedByteInstanceVariables class", "String", "Integer"};
01642 static char* errors_164[] = { "ConversionFailed", NULL};
01643 static primitive_desc primitive_164 = {
01644 "primitiveIndexedByteLargeIntegerFromString:base:ifFail:",
01645 fntype(&byteArrayPrimitives::largeIntegerFromString),
01646 1312259,
01647 signature_164,
01648 errors_164
01649 };
01650
01651 static char* signature_165[] = { "IndexedByteInstanceVariables|SmallInteger", "IndexedByteInstanceVariables", "IndexedByteInstanceVariables"};
01652 static char* errors_165[] = { "ArgumentIsInvalid", "DivisionByZero", NULL};
01653 static primitive_desc primitive_165 = {
01654 "primitiveIndexedByteLargeIntegerMod:ifFail:",
01655 fntype(&byteArrayPrimitives::largeIntegerMod),
01656 1312258,
01657 signature_165,
01658 errors_165
01659 };
01660
01661 static char* signature_166[] = { "IndexedByteInstanceVariables|SmallInteger", "IndexedByteInstanceVariables", "IndexedByteInstanceVariables"};
01662 static char* errors_166[] = { "ArgumentIsInvalid", NULL};
01663 static primitive_desc primitive_166 = {
01664 "primitiveIndexedByteLargeIntegerMultiply:ifFail:",
01665 fntype(&byteArrayPrimitives::largeIntegerMultiply),
01666 1312258,
01667 signature_166,
01668 errors_166
01669 };
01670
01671 static char* signature_167[] = { "IndexedByteInstanceVariables|SmallInteger", "IndexedByteInstanceVariables", "IndexedByteInstanceVariables"};
01672 static char* errors_167[] = { "ArgumentIsInvalid", NULL};
01673 static primitive_desc primitive_167 = {
01674 "primitiveIndexedByteLargeIntegerSubtract:ifFail:",
01675 fntype(&byteArrayPrimitives::largeIntegerSubtract),
01676 1312258,
01677 signature_167,
01678 errors_167
01679 };
01680
01681 static char* signature_168[] = { "String", "IndexedByteInstanceVariables", "SmallInteger"};
01682 static char* errors_168[] = {NULL};
01683 static primitive_desc primitive_168 = {
01684 "primitiveIndexedByteLargeIntegerToStringBase:ifFail:",
01685 fntype(&byteArrayPrimitives::largeIntegerToString),
01686 1312258,
01687 signature_168,
01688 errors_168
01689 };
01690
01691 static char* signature_169[] = { "Object", "IndexedByteInstanceVariables class", "SmallInteger"};
01692 static char* errors_169[] = { "NegativeSize", NULL};
01693 static primitive_desc primitive_169 = {
01694 "primitiveIndexedByteNew:ifFail:",
01695 fntype(&byteArrayPrimitives::allocateSize),
01696 1376258,
01697 signature_169,
01698 errors_169
01699 };
01700
01701 static char* signature_170[] = { "SmallInteger", "IndexedByteInstanceVariables"};
01702 static char* errors_170[] = {NULL};
01703 static primitive_desc primitive_170 = {
01704 "primitiveIndexedByteSize",
01705 fntype(&byteArrayPrimitives::size),
01706 1574401,
01707 signature_170,
01708 errors_170
01709 };
01710
01711 static char* signature_171[] = { "SmallInteger", "IndexedDoubleByteInstanceVariables", "SmallInteger"};
01712 static char* errors_171[] = { "OutOfBounds", NULL};
01713 static primitive_desc primitive_171 = {
01714 "primitiveIndexedDoubleByteAt:ifFail:",
01715 fntype(&doubleByteArrayPrimitives::at),
01716 1312514,
01717 signature_171,
01718 errors_171
01719 };
01720
01721 static char* signature_172[] = { "SmallInteger", "IndexedDoubleByteInstanceVariables", "SmallInteger", "SmallInteger"};
01722 static char* errors_172[] = { "OutOfBounds", "ValueOutOfBounds", NULL};
01723 static primitive_desc primitive_172 = {
01724 "primitiveIndexedDoubleByteAt:put:ifFail:",
01725 fntype(&doubleByteArrayPrimitives::atPut),
01726 1312515,
01727 signature_172,
01728 errors_172
01729 };
01730
01731 static char* signature_173[] = { "SmallInteger", "IndexedDoubleByteInstanceVariables", "SmallInteger"};
01732 static char* errors_173[] = { "OutOfBounds", NULL};
01733 static primitive_desc primitive_173 = {
01734 "primitiveIndexedDoubleByteCharacterAt:ifFail:",
01735 fntype(&doubleByteArrayPrimitives::characterAt),
01736 1312514,
01737 signature_173,
01738 errors_173
01739 };
01740
01741 static char* signature_174[] = { "SmallInteger", "IndexedDoubleByteInstanceVariables", "String"};
01742 static char* errors_174[] = {NULL};
01743 static primitive_desc primitive_174 = {
01744 "primitiveIndexedDoubleByteCompare:ifFail:",
01745 fntype(&doubleByteArrayPrimitives::compare),
01746 1310722,
01747 signature_174,
01748 errors_174
01749 };
01750
01751 static char* signature_175[] = { "SmallInteger", "IndexedDoubleByteInstanceVariables"};
01752 static char* errors_175[] = {NULL};
01753 static primitive_desc primitive_175 = {
01754 "primitiveIndexedDoubleByteHash",
01755 fntype(&doubleByteArrayPrimitives::hash),
01756 1114113,
01757 signature_175,
01758 errors_175
01759 };
01760
01761 static char* signature_176[] = { "CompressedSymbol", "IndexedDoubleByteInstanceVariables"};
01762 static char* errors_176[] = { "ValueOutOfBounds", NULL};
01763 static primitive_desc primitive_176 = {
01764 "primitiveIndexedDoubleByteInternIfFail:",
01765 fntype(&doubleByteArrayPrimitives::intern),
01766 1376257,
01767 signature_176,
01768 errors_176
01769 };
01770
01771 static char* signature_177[] = { "Object", "IndexedDoubleByteInstanceVariables class", "SmallInteger"};
01772 static char* errors_177[] = { "NegativeSize", NULL};
01773 static primitive_desc primitive_177 = {
01774 "primitiveIndexedDoubleByteNew:ifFail:",
01775 fntype(&doubleByteArrayPrimitives::allocateSize),
01776 1376258,
01777 signature_177,
01778 errors_177
01779 };
01780
01781 static char* signature_178[] = { "SmallInteger", "IndexedDoubleByteInstanceVariables"};
01782 static char* errors_178[] = {NULL};
01783 static primitive_desc primitive_178 = {
01784 "primitiveIndexedDoubleByteSize",
01785 fntype(&doubleByteArrayPrimitives::size),
01786 1574657,
01787 signature_178,
01788 errors_178
01789 };
01790
01791 static char* signature_179[] = { "Float", "IndexedFloatValueInstanceVariables", "SmallInteger"};
01792 static char* errors_179[] = { "OutOfBounds", NULL};
01793 static primitive_desc primitive_179 = {
01794 "primitiveIndexedFloatValueAt:ifFail:",
01795 fntype(&doubleValueArrayPrimitives::at),
01796 1310722,
01797 signature_179,
01798 errors_179
01799 };
01800
01801 static char* signature_180[] = { "Float", "IndexedFloatValueInstanceVariables", "SmallInteger", "Float"};
01802 static char* errors_180[] = { "OutOfBounds", "ValueOutOfBounds", NULL};
01803 static primitive_desc primitive_180 = {
01804 "primitiveIndexedFloatValueAt:put:ifFail:",
01805 fntype(&doubleValueArrayPrimitives::atPut),
01806 1310723,
01807 signature_180,
01808 errors_180
01809 };
01810
01811 static char* signature_181[] = { "Object", "IndexedFloatValueInstanceVariables class", "SmallInteger"};
01812 static char* errors_181[] = { "NegativeSize", NULL};
01813 static primitive_desc primitive_181 = {
01814 "primitiveIndexedFloatValueNew:ifFail:",
01815 fntype(&doubleValueArrayPrimitives::allocateSize),
01816 1376258,
01817 signature_181,
01818 errors_181
01819 };
01820
01821 static char* signature_182[] = { "SmallInteger", "IndexedFloatValueInstanceVariables"};
01822 static char* errors_182[] = {NULL};
01823 static primitive_desc primitive_182 = {
01824 "primitiveIndexedFloatValueSize",
01825 fntype(&doubleValueArrayPrimitives::size),
01826 1572865,
01827 signature_182,
01828 errors_182
01829 };
01830
01831 static char* signature_183[] = { "SmallInteger", "IndexedInstanceVariables", "SmallInteger"};
01832 static char* errors_183[] = { "OutOfBounds", NULL};
01833 static primitive_desc primitive_183 = {
01834 "primitiveIndexedObjectAt:ifFail:",
01835 fntype(&objArrayPrimitives::at),
01836 1312002,
01837 signature_183,
01838 errors_183
01839 };
01840
01841 static char* signature_184[] = { "Object", "IndexedInstanceVariables", "SmallInteger", "Object"};
01842 static char* errors_184[] = { "OutOfBounds", NULL};
01843 static primitive_desc primitive_184 = {
01844 "primitiveIndexedObjectAt:put:ifFail:",
01845 fntype(&objArrayPrimitives::atPut),
01846 1312003,
01847 signature_184,
01848 errors_184
01849 };
01850
01851 static char* signature_185[] = { "Self", "IndexedInstanceVariables", "Object"};
01852 static char* errors_185[] = {NULL};
01853 static primitive_desc primitive_185 = {
01854 "primitiveIndexedObjectAtAllPut:",
01855 fntype(&objArrayPrimitives::at_all_put),
01856 1049858,
01857 signature_185,
01858 errors_185
01859 };
01860
01861 static char* signature_186[] = { "Self", "IndexedInstanceVariables", "SmallInteger", "SmallInteger", "SmallInteger"};
01862 static char* errors_186[] = { "OutOfBounds", "NegativeSize", NULL};
01863 static primitive_desc primitive_186 = {
01864 "primitiveIndexedObjectCopyFrom:startingAt:size:ifFail:",
01865 fntype(&objArrayPrimitives::copy_size),
01866 1377540,
01867 signature_186,
01868 errors_186
01869 };
01870
01871 static char* signature_187[] = { "Object", "IndexedInstanceVariables class", "SmallInteger"};
01872 static char* errors_187[] = { "NegativeSize", NULL};
01873 static primitive_desc primitive_187 = {
01874 "primitiveIndexedObjectNew:ifFail:",
01875 fntype(&objArrayPrimitives::allocateSize),
01876 1376258,
01877 signature_187,
01878 errors_187
01879 };
01880
01881 static char* signature_188[] = { "Self", "IndexedInstanceVariables", "SmallInteger", "SmallInteger", "IndexedInstanceVariables", "SmallInteger"};
01882 static char* errors_188[] = { "OutOfBounds", NULL};
01883 static primitive_desc primitive_188 = {
01884 "primitiveIndexedObjectReplaceFrom:to:with:startingAt:ifFail:",
01885 fntype(&objArrayPrimitives::replace_from_to),
01886 1377541,
01887 signature_188,
01888 errors_188
01889 };
01890
01891 static char* signature_189[] = { "Self", "IndexedInstanceVariables"};
01892 static char* errors_189[] = {NULL};
01893 static primitive_desc primitive_189 = {
01894 "primitiveIndexedObjectSize",
01895 fntype(&objArrayPrimitives::size),
01896 1574145,
01897 signature_189,
01898 errors_189
01899 };
01900
01901 static char* signature_190[] = { "Boolean", "Behavior", "Symbol"};
01902 static char* errors_190[] = {NULL};
01903 static primitive_desc primitive_190 = {
01904 "primitiveInliningDatabaseAddLookupEntryClass:selector:ifFail:",
01905 fntype(&systemPrimitives::inlining_database_add_entry),
01906 327682,
01907 signature_190,
01908 errors_190
01909 };
01910
01911 static char* signature_191[] = { "Boolean"};
01912 static char* errors_191[] = {NULL};
01913 static primitive_desc primitive_191 = {
01914 "primitiveInliningDatabaseCompile",
01915 fntype(&systemPrimitives::inlining_database_compile_next),
01916 65536,
01917 signature_191,
01918 errors_191
01919 };
01920
01921 static char* signature_192[] = { "Object", "String"};
01922 static char* errors_192[] = {NULL};
01923 static primitive_desc primitive_192 = {
01924 "primitiveInliningDatabaseCompile:ifFail:",
01925 fntype(&systemPrimitives::inlining_database_compile),
01926 327681,
01927 signature_192,
01928 errors_192
01929 };
01930
01931 static char* signature_193[] = { "IndexedByteInstanceVariables", "String"};
01932 static char* errors_193[] = {NULL};
01933 static primitive_desc primitive_193 = {
01934 "primitiveInliningDatabaseCompileDemangled:ifFail:",
01935 fntype(&systemPrimitives::inlining_database_demangle),
01936 327681,
01937 signature_193,
01938 errors_193
01939 };
01940
01941 static char* signature_194[] = { "Symbol"};
01942 static char* errors_194[] = {NULL};
01943 static primitive_desc primitive_194 = {
01944 "primitiveInliningDatabaseDirectory",
01945 fntype(&systemPrimitives::inlining_database_directory),
01946 65536,
01947 signature_194,
01948 errors_194
01949 };
01950
01951 static char* signature_195[] = { "SmallInteger"};
01952 static char* errors_195[] = {NULL};
01953 static primitive_desc primitive_195 = {
01954 "primitiveInliningDatabaseFileOutAllIfFail:",
01955 fntype(&systemPrimitives::inlining_database_file_out_all),
01956 327680,
01957 signature_195,
01958 errors_195
01959 };
01960
01961 static char* signature_196[] = { "SmallInteger", "Behavior"};
01962 static char* errors_196[] = {NULL};
01963 static primitive_desc primitive_196 = {
01964 "primitiveInliningDatabaseFileOutClass:ifFail:",
01965 fntype(&systemPrimitives::inlining_database_file_out_class),
01966 327681,
01967 signature_196,
01968 errors_196
01969 };
01970
01971 static char* signature_197[] = { "IndexedByteInstanceVariables", "String"};
01972 static char* errors_197[] = {NULL};
01973 static primitive_desc primitive_197 = {
01974 "primitiveInliningDatabaseMangle:ifFail:",
01975 fntype(&systemPrimitives::inlining_database_mangle),
01976 327681,
01977 signature_197,
01978 errors_197
01979 };
01980
01981 static char* signature_198[] = { "Symbol", "Symbol"};
01982 static char* errors_198[] = {NULL};
01983 static primitive_desc primitive_198 = {
01984 "primitiveInliningDatabaseSetDirectory:ifFail:",
01985 fntype(&systemPrimitives::inlining_database_set_directory),
01986 327681,
01987 signature_198,
01988 errors_198
01989 };
01990
01991 static char* signature_199[] = { "Object", "Object", "SmallInteger"};
01992 static char* errors_199[] = { "OutOfBounds", NULL};
01993 static primitive_desc primitive_199 = {
01994 "primitiveInstVarAt:ifFail:",
01995 fntype(&oopPrimitives::instVarAt),
01996 1376258,
01997 signature_199,
01998 errors_199
01999 };
02000
02001 static char* signature_200[] = { "Object", "Object", "SmallInteger", "Object"};
02002 static char* errors_200[] = { "OutOfBounds", NULL};
02003 static primitive_desc primitive_200 = {
02004 "primitiveInstVarAt:put:ifFail:",
02005 fntype(&oopPrimitives::instVarAtPut),
02006 1376259,
02007 signature_200,
02008 errors_200
02009 };
02010
02011 static char* signature_201[] = { "Symbol", "Reciever", "Object", "SmallInteger"};
02012 static char* errors_201[] = { "OutOfBounds", NULL};
02013 static primitive_desc primitive_201 = {
02014 "primitiveInstVarNameFor:at:ifFail:",
02015 fntype(&oopPrimitives::instance_variable_name_at),
02016 1376259,
02017 signature_201,
02018 errors_201
02019 };
02020
02021 static char* signature_202[] = { "IndexedInstanceVariables", "Class", "SmallInteger"};
02022 static char* errors_202[] = {NULL};
02023 static primitive_desc primitive_202 = {
02024 "primitiveInstancesOf:limit:ifFail:",
02025 fntype(&systemPrimitives::instances_of),
02026 327682,
02027 signature_202,
02028 errors_202
02029 };
02030
02031 static char* signature_203[] = { "SmallInteger"};
02032 static char* errors_203[] = {NULL};
02033 static primitive_desc primitive_203 = {
02034 "primitiveInterpreterInvocationCounterLimit",
02035 fntype(&debugPrimitives::interpreterInvocationCounterLimit),
02036 65536,
02037 signature_203,
02038 errors_203
02039 };
02040
02041 static char* signature_204[] = { "Boolean", "SmallInteger", "SmallInteger"};
02042 static char* errors_204[] = {NULL};
02043 static primitive_desc primitive_204 = {
02044 "primitiveLessThan:ifFail:",
02045 fntype(&smiOopPrimitives::lessThan),
02046 6029570,
02047 signature_204,
02048 errors_204
02049 };
02050
02051 static char* signature_205[] = { "Boolean", "SmallInteger", "SmallInteger"};
02052 static char* errors_205[] = {NULL};
02053 static primitive_desc primitive_205 = {
02054 "primitiveLessThanOrEqual:ifFail:",
02055 fntype(&smiOopPrimitives::lessThanOrEqual),
02056 6029570,
02057 signature_205,
02058 errors_205
02059 };
02060
02061 static char* signature_206[] = { "SmallInteger", "Float", "Float", "SmallInteger"};
02062 static char* errors_206[] = {NULL};
02063 static primitive_desc primitive_206 = {
02064 "primitiveMandelbrotAtRe:im:iterate:ifFail:",
02065 fntype(&doubleOopPrimitives::mandelbrot),
02066 4980739,
02067 signature_206,
02068 errors_206
02069 };
02070
02071 static char* signature_207[] = { "Block", "Method", "Object"};
02072 static char* errors_207[] = {NULL};
02073 static primitive_desc primitive_207 = {
02074 "primitiveMethodAllocateBlock:ifFail:",
02075 fntype(&methodOopPrimitives::allocate_block_self),
02076 1376258,
02077 signature_207,
02078 errors_207
02079 };
02080
02081 static char* signature_208[] = { "Block", "Method"};
02082 static char* errors_208[] = {NULL};
02083 static primitive_desc primitive_208 = {
02084 "primitiveMethodAllocateBlockIfFail:",
02085 fntype(&methodOopPrimitives::allocate_block),
02086 1376257,
02087 signature_208,
02088 errors_208
02089 };
02090
02091 static char* signature_209[] = { "Object", "Method"};
02092 static char* errors_209[] = {NULL};
02093 static primitive_desc primitive_209 = {
02094 "primitiveMethodBody",
02095 fntype(&methodOopPrimitives::fileout_body),
02096 1114113,
02097 signature_209,
02098 errors_209
02099 };
02100
02101 static char* signature_210[] = { "Object", "Method"};
02102 static char* errors_210[] = {NULL};
02103 static primitive_desc primitive_210 = {
02104 "primitiveMethodDebugInfo",
02105 fntype(&methodOopPrimitives::debug_info),
02106 1114113,
02107 signature_210,
02108 errors_210
02109 };
02110
02111 static char* signature_211[] = { "Method", "Behavior", "CompressedSymbol"};
02112 static char* errors_211[] = { "NotFound", NULL};
02113 static primitive_desc primitive_211 = {
02114 "primitiveMethodFor:ifFail:",
02115 fntype(&behaviorPrimitives::methodFor),
02116 1376258,
02117 signature_211,
02118 errors_211
02119 };
02120
02121 static char* signature_212[] = { "Symbol", "Method"};
02122 static char* errors_212[] = {NULL};
02123 static primitive_desc primitive_212 = {
02124 "primitiveMethodInliningInfo",
02125 fntype(&methodOopPrimitives::inlining_info),
02126 1114113,
02127 signature_212,
02128 errors_212
02129 };
02130
02131 static char* signature_213[] = { "SmallInteger", "Method"};
02132 static char* errors_213[] = {NULL};
02133 static primitive_desc primitive_213 = {
02134 "primitiveMethodNumberOfArguments",
02135 fntype(&methodOopPrimitives::numberOfArguments),
02136 1114113,
02137 signature_213,
02138 errors_213
02139 };
02140
02141 static char* signature_214[] = { "Symbol", "Method", "Method"};
02142 static char* errors_214[] = {NULL};
02143 static primitive_desc primitive_214 = {
02144 "primitiveMethodOuter:ifFail:",
02145 fntype(&methodOopPrimitives::setOuter),
02146 1376258,
02147 signature_214,
02148 errors_214
02149 };
02150
02151 static char* signature_215[] = { "Method", "Method"};
02152 static char* errors_215[] = { "ReceiverNotBlockMethod", NULL};
02153 static primitive_desc primitive_215 = {
02154 "primitiveMethodOuterIfFail:",
02155 fntype(&methodOopPrimitives::outer),
02156 1376257,
02157 signature_215,
02158 errors_215
02159 };
02160
02161 static char* signature_216[] = { "Method", "Method", "Object"};
02162 static char* errors_216[] = {NULL};
02163 static primitive_desc primitive_216 = {
02164 "primitiveMethodPrettyPrintKlass:ifFail:",
02165 fntype(&methodOopPrimitives::prettyPrint),
02166 1376258,
02167 signature_216,
02168 errors_216
02169 };
02170
02171 static char* signature_217[] = { "ByteIndexedInstanceVariables", "Method", "Object"};
02172 static char* errors_217[] = {NULL};
02173 static primitive_desc primitive_217 = {
02174 "primitiveMethodPrettyPrintSourceKlass:ifFail:",
02175 fntype(&methodOopPrimitives::prettyPrintSource),
02176 1376258,
02177 signature_217,
02178 errors_217
02179 };
02180
02181 static char* signature_218[] = { "Symbol", "Method"};
02182 static char* errors_218[] = {NULL};
02183 static primitive_desc primitive_218 = {
02184 "primitiveMethodPrintCodes",
02185 fntype(&methodOopPrimitives::printCodes),
02186 1114113,
02187 signature_218,
02188 errors_218
02189 };
02190
02191 static char* signature_219[] = { "IndexedInstanceVariables", "Method"};
02192 static char* errors_219[] = {NULL};
02193 static primitive_desc primitive_219 = {
02194 "primitiveMethodReferencedClassVarNames",
02195 fntype(&methodOopPrimitives::referenced_class_variable_names),
02196 1114113,
02197 signature_219,
02198 errors_219
02199 };
02200
02201 static char* signature_220[] = { "IndexedInstanceVariables", "Method"};
02202 static char* errors_220[] = {NULL};
02203 static primitive_desc primitive_220 = {
02204 "primitiveMethodReferencedGlobalNames",
02205 fntype(&methodOopPrimitives::referenced_global_names),
02206 1114113,
02207 signature_220,
02208 errors_220
02209 };
02210
02211 static char* signature_221[] = { "IndexedInstanceVariables", "Method", "Mixin"};
02212 static char* errors_221[] = {NULL};
02213 static primitive_desc primitive_221 = {
02214 "primitiveMethodReferencedInstVarNamesMixin:ifFail:",
02215 fntype(&methodOopPrimitives::referenced_instance_variable_names),
02216 1376258,
02217 signature_221,
02218 errors_221
02219 };
02220
02221 static char* signature_222[] = { "Symbol", "Method"};
02222 static char* errors_222[] = {NULL};
02223 static primitive_desc primitive_222 = {
02224 "primitiveMethodSelector",
02225 fntype(&methodOopPrimitives::selector),
02226 1114113,
02227 signature_222,
02228 errors_222
02229 };
02230
02231 static char* signature_223[] = { "Symbol", "Method", "Symbol"};
02232 static char* errors_223[] = {NULL};
02233 static primitive_desc primitive_223 = {
02234 "primitiveMethodSelector:ifFail:",
02235 fntype(&methodOopPrimitives::setSelector),
02236 1376258,
02237 signature_223,
02238 errors_223
02239 };
02240
02241 static char* signature_224[] = { "IndexedInstanceVariables", "Method"};
02242 static char* errors_224[] = {NULL};
02243 static primitive_desc primitive_224 = {
02244 "primitiveMethodSenders",
02245 fntype(&methodOopPrimitives::senders),
02246 1114113,
02247 signature_224,
02248 errors_224
02249 };
02250
02251 static char* signature_225[] = { "Symbol", "Method", "Symbol"};
02252 static char* errors_225[] = { "ArgumentIsInvalid", NULL};
02253 static primitive_desc primitive_225 = {
02254 "primitiveMethodSetInliningInfo:ifFail:",
02255 fntype(&methodOopPrimitives::set_inlining_info),
02256 1376258,
02257 signature_225,
02258 errors_225
02259 };
02260
02261 static char* signature_226[] = { "Object", "Method"};
02262 static char* errors_226[] = {NULL};
02263 static primitive_desc primitive_226 = {
02264 "primitiveMethodSizeAndFlags",
02265 fntype(&methodOopPrimitives::size_and_flags),
02266 1114113,
02267 signature_226,
02268 errors_226
02269 };
02270
02271 static char* signature_227[] = { "Mixin", "Mixin", "Symbol"};
02272 static char* errors_227[] = { "IsInstalled", "OutOfBounds", NULL};
02273 static primitive_desc primitive_227 = {
02274 "primitiveMixin:addClassVariable:ifFail:",
02275 fntype(&mixinOopPrimitives::add_class_variable),
02276 327682,
02277 signature_227,
02278 errors_227
02279 };
02280
02281 static char* signature_228[] = { "Symbol", "Mixin", "Symbol"};
02282 static char* errors_228[] = { "IsInstalled", "OutOfBounds", NULL};
02283 static primitive_desc primitive_228 = {
02284 "primitiveMixin:addInstanceVariable:ifFail:",
02285 fntype(&mixinOopPrimitives::add_instance_variable),
02286 327682,
02287 signature_228,
02288 errors_228
02289 };
02290
02291 static char* signature_229[] = { "Method", "Mixin", "Method"};
02292 static char* errors_229[] = { "IsInstalled", NULL};
02293 static primitive_desc primitive_229 = {
02294 "primitiveMixin:addMethod:ifFail:",
02295 fntype(&mixinOopPrimitives::add_method),
02296 327682,
02297 signature_229,
02298 errors_229
02299 };
02300
02301 static char* signature_230[] = { "Symbol", "Mixin", "SmallInteger"};
02302 static char* errors_230[] = { "OutOfBounds", NULL};
02303 static primitive_desc primitive_230 = {
02304 "primitiveMixin:classVariableAt:ifFail:",
02305 fntype(&mixinOopPrimitives::class_variable_at),
02306 327682,
02307 signature_230,
02308 errors_230
02309 };
02310
02311 static char* signature_231[] = { "Symbol", "Mixin"};
02312 static char* errors_231[] = {NULL};
02313 static primitive_desc primitive_231 = {
02314 "primitiveMixin:classVariablesIfFail:",
02315 fntype(&mixinOopPrimitives::class_variables),
02316 327681,
02317 signature_231,
02318 errors_231
02319 };
02320
02321 static char* signature_232[] = { "Symbol", "Mixin", "SmallInteger"};
02322 static char* errors_232[] = { "OutOfBounds", NULL};
02323 static primitive_desc primitive_232 = {
02324 "primitiveMixin:instanceVariableAt:ifFail:",
02325 fntype(&mixinOopPrimitives::instance_variable_at),
02326 327682,
02327 signature_232,
02328 errors_232
02329 };
02330
02331 static char* signature_233[] = { "Symbol", "Mixin"};
02332 static char* errors_233[] = {NULL};
02333 static primitive_desc primitive_233 = {
02334 "primitiveMixin:instanceVariablesIfFail:",
02335 fntype(&mixinOopPrimitives::instance_variables),
02336 327681,
02337 signature_233,
02338 errors_233
02339 };
02340
02341 static char* signature_234[] = { "Method", "Mixin", "SmallInteger"};
02342 static char* errors_234[] = { "OutOfBounds", NULL};
02343 static primitive_desc primitive_234 = {
02344 "primitiveMixin:methodAt:ifFail:",
02345 fntype(&mixinOopPrimitives::method_at),
02346 327682,
02347 signature_234,
02348 errors_234
02349 };
02350
02351 static char* signature_235[] = { "Symbol", "Mixin"};
02352 static char* errors_235[] = {NULL};
02353 static primitive_desc primitive_235 = {
02354 "primitiveMixin:methodsIfFail:",
02355 fntype(&mixinOopPrimitives::methods),
02356 327681,
02357 signature_235,
02358 errors_235
02359 };
02360
02361 static char* signature_236[] = { "Symbol", "Mixin", "SmallInteger"};
02362 static char* errors_236[] = { "IsInstalled", "OutOfBounds", NULL};
02363 static primitive_desc primitive_236 = {
02364 "primitiveMixin:removeClassVariableAt:ifFail:",
02365 fntype(&mixinOopPrimitives::remove_class_variable_at),
02366 327682,
02367 signature_236,
02368 errors_236
02369 };
02370
02371 static char* signature_237[] = { "Symbol", "Mixin", "SmallInteger"};
02372 static char* errors_237[] = { "IsInstalled", "OutOfBounds", NULL};
02373 static primitive_desc primitive_237 = {
02374 "primitiveMixin:removeInstanceVariableAt:ifFail:",
02375 fntype(&mixinOopPrimitives::remove_instance_variable_at),
02376 327682,
02377 signature_237,
02378 errors_237
02379 };
02380
02381 static char* signature_238[] = { "Method", "Mixin", "SmallInteger"};
02382 static char* errors_238[] = { "IsInstalled", "OutOfBounds", NULL};
02383 static primitive_desc primitive_238 = {
02384 "primitiveMixin:removeMethodAt:ifFail:",
02385 fntype(&mixinOopPrimitives::remove_method_at),
02386 327682,
02387 signature_238,
02388 errors_238
02389 };
02390
02391 static char* signature_239[] = { "Mixin", "Mixin"};
02392 static char* errors_239[] = {NULL};
02393 static primitive_desc primitive_239 = {
02394 "primitiveMixinClassMixinOf:ifFail:",
02395 fntype(&mixinOopPrimitives::class_mixin),
02396 327681,
02397 signature_239,
02398 errors_239
02399 };
02400
02401 static char* signature_240[] = { "Boolean", "Mixin"};
02402 static char* errors_240[] = {NULL};
02403 static primitive_desc primitive_240 = {
02404 "primitiveMixinIsInstalled:ifFail:",
02405 fntype(&mixinOopPrimitives::is_installed),
02406 327681,
02407 signature_240,
02408 errors_240
02409 };
02410
02411 static char* signature_241[] = { "SmallInteger", "Mixin"};
02412 static char* errors_241[] = {NULL};
02413 static primitive_desc primitive_241 = {
02414 "primitiveMixinNumberOfClassVariablesOf:ifFail:",
02415 fntype(&mixinOopPrimitives::number_of_class_variables),
02416 327681,
02417 signature_241,
02418 errors_241
02419 };
02420
02421 static char* signature_242[] = { "SmallInteger", "Mixin"};
02422 static char* errors_242[] = {NULL};
02423 static primitive_desc primitive_242 = {
02424 "primitiveMixinNumberOfInstanceVariablesOf:ifFail:",
02425 fntype(&mixinOopPrimitives::number_of_instance_variables),
02426 327681,
02427 signature_242,
02428 errors_242
02429 };
02430
02431 static char* signature_243[] = { "SmallInteger", "Mixin"};
02432 static char* errors_243[] = {NULL};
02433 static primitive_desc primitive_243 = {
02434 "primitiveMixinNumberOfMethodsOf:ifFail:",
02435 fntype(&mixinOopPrimitives::number_of_methods),
02436 327681,
02437 signature_243,
02438 errors_243
02439 };
02440
02441 static char* signature_244[] = { "Class", "Mixin"};
02442 static char* errors_244[] = {NULL};
02443 static primitive_desc primitive_244 = {
02444 "primitiveMixinPrimaryInvocationOf:ifFail:",
02445 fntype(&mixinOopPrimitives::primary_invocation),
02446 327681,
02447 signature_244,
02448 errors_244
02449 };
02450
02451 static char* signature_245[] = { "Mixin", "Mixin", "Mixin"};
02452 static char* errors_245[] = { "IsInstalled", NULL};
02453 static primitive_desc primitive_245 = {
02454 "primitiveMixinSetClassMixinOf:to:ifFail:",
02455 fntype(&mixinOopPrimitives::set_class_mixin),
02456 327682,
02457 signature_245,
02458 errors_245
02459 };
02460
02461 static char* signature_246[] = { "Boolean", "Mixin"};
02462 static char* errors_246[] = {NULL};
02463 static primitive_desc primitive_246 = {
02464 "primitiveMixinSetInstalled:ifFail:",
02465 fntype(&mixinOopPrimitives::set_installed),
02466 327681,
02467 signature_246,
02468 errors_246
02469 };
02470
02471 static char* signature_247[] = { "Class", "Mixin", "Class"};
02472 static char* errors_247[] = { "IsInstalled", NULL};
02473 static primitive_desc primitive_247 = {
02474 "primitiveMixinSetPrimaryInvocationOf:to:ifFail:",
02475 fntype(&mixinOopPrimitives::set_primary_invocation),
02476 327682,
02477 signature_247,
02478 errors_247
02479 };
02480
02481 static char* signature_248[] = { "Boolean", "Mixin"};
02482 static char* errors_248[] = {NULL};
02483 static primitive_desc primitive_248 = {
02484 "primitiveMixinSetUnInstalled:ifFail:",
02485 fntype(&mixinOopPrimitives::set_uninstalled),
02486 327681,
02487 signature_248,
02488 errors_248
02489 };
02490
02491 static char* signature_249[] = { "SmallInteger", "SmallInteger", "SmallInteger"};
02492 static char* errors_249[] = { "Overflow", "DivisionByZero", NULL};
02493 static primitive_desc primitive_249 = {
02494 "primitiveMod:ifFail:",
02495 fntype(&smiOopPrimitives_mod),
02496 6029826,
02497 signature_249,
02498 errors_249
02499 };
02500
02501 static char* signature_250[] = { "SmallInteger", "SmallInteger", "SmallInteger"};
02502 static char* errors_250[] = { "Overflow", NULL};
02503 static primitive_desc primitive_250 = {
02504 "primitiveMultiply:ifFail:",
02505 fntype(&smiOopPrimitives_multiply),
02506 6029826,
02507 signature_250,
02508 errors_250
02509 };
02510
02511 static char* signature_251[] = { "Object", "Behavior"};
02512 static char* errors_251[] = {NULL};
02513 static primitive_desc primitive_251 = {
02514 "primitiveNew0",
02515 fntype(&primitiveNew0),
02516 7405569,
02517 signature_251,
02518 errors_251
02519 };
02520
02521 static char* signature_252[] = { "Instance", "Behavior"};
02522 static char* errors_252[] = {NULL};
02523 static primitive_desc primitive_252 = {
02524 "primitiveNew1",
02525 fntype(&primitiveNew1),
02526 7405569,
02527 signature_252,
02528 errors_252
02529 };
02530
02531 static char* signature_253[] = { "Instance", "Behavior"};
02532 static char* errors_253[] = {NULL};
02533 static primitive_desc primitive_253 = {
02534 "primitiveNew2",
02535 fntype(&primitiveNew2),
02536 7405569,
02537 signature_253,
02538 errors_253
02539 };
02540
02541 static char* signature_254[] = { "Instance", "Behavior"};
02542 static char* errors_254[] = {NULL};
02543 static primitive_desc primitive_254 = {
02544 "primitiveNew3",
02545 fntype(&primitiveNew3),
02546 7405569,
02547 signature_254,
02548 errors_254
02549 };
02550
02551 static char* signature_255[] = { "Instance", "Behavior"};
02552 static char* errors_255[] = {NULL};
02553 static primitive_desc primitive_255 = {
02554 "primitiveNew4",
02555 fntype(&primitiveNew4),
02556 7405569,
02557 signature_255,
02558 errors_255
02559 };
02560
02561 static char* signature_256[] = { "Instance", "Behavior"};
02562 static char* errors_256[] = {NULL};
02563 static primitive_desc primitive_256 = {
02564 "primitiveNew5",
02565 fntype(&primitiveNew5),
02566 7405569,
02567 signature_256,
02568 errors_256
02569 };
02570
02571 static char* signature_257[] = { "Instance", "Behavior"};
02572 static char* errors_257[] = {NULL};
02573 static primitive_desc primitive_257 = {
02574 "primitiveNew6",
02575 fntype(&primitiveNew6),
02576 7405569,
02577 signature_257,
02578 errors_257
02579 };
02580
02581 static char* signature_258[] = { "Instance", "Behavior"};
02582 static char* errors_258[] = {NULL};
02583 static primitive_desc primitive_258 = {
02584 "primitiveNew7",
02585 fntype(&primitiveNew7),
02586 7405569,
02587 signature_258,
02588 errors_258
02589 };
02590
02591 static char* signature_259[] = { "Instance", "Behavior"};
02592 static char* errors_259[] = {NULL};
02593 static primitive_desc primitive_259 = {
02594 "primitiveNew8",
02595 fntype(&primitiveNew8),
02596 7405569,
02597 signature_259,
02598 errors_259
02599 };
02600
02601 static char* signature_260[] = { "Instance", "Behavior"};
02602 static char* errors_260[] = {NULL};
02603 static primitive_desc primitive_260 = {
02604 "primitiveNew9",
02605 fntype(&primitiveNew9),
02606 7405569,
02607 signature_260,
02608 errors_260
02609 };
02610
02611 static char* signature_261[] = { "Instance", "Behavior"};
02612 static char* errors_261[] = { "ReceiverIsIndexable", NULL};
02613 static primitive_desc primitive_261 = {
02614 "primitiveNewIfFail:",
02615 fntype(&behaviorPrimitives::allocate),
02616 1376257,
02617 signature_261,
02618 errors_261
02619 };
02620
02621 static char* signature_262[] = { "Boolean", "Object", "Object"};
02622 static char* errors_262[] = {NULL};
02623 static primitive_desc primitive_262 = {
02624 "primitiveNotEqual:",
02625 fntype(&oopPrimitives::not_equal),
02626 1572866,
02627 signature_262,
02628 errors_262
02629 };
02630
02631 static char* signature_263[] = { "Object"};
02632 static char* errors_263[] = { "EmptyQueue", NULL};
02633 static primitive_desc primitive_263 = {
02634 "primitiveNotificationQueueGetIfFail:",
02635 fntype(&systemPrimitives::notificationQueueGet),
02636 327680,
02637 signature_263,
02638 errors_263
02639 };
02640
02641 static char* signature_264[] = { "Object", "Object"};
02642 static char* errors_264[] = {NULL};
02643 static primitive_desc primitive_264 = {
02644 "primitiveNotificationQueuePut:",
02645 fntype(&systemPrimitives::notificationQueuePut),
02646 65537,
02647 signature_264,
02648 errors_264
02649 };
02650
02651 static char* signature_265[] = { "SmallInteger"};
02652 static char* errors_265[] = {NULL};
02653 static primitive_desc primitive_265 = {
02654 "primitiveNumberOfLookupCacheMisses",
02655 fntype(&debugPrimitives::numberOfLookupCacheMisses),
02656 65536,
02657 signature_265,
02658 errors_265
02659 };
02660
02661 static char* signature_266[] = { "SmallInteger"};
02662 static char* errors_266[] = {NULL};
02663 static primitive_desc primitive_266 = {
02664 "primitiveNumberOfMethodInvocations",
02665 fntype(&debugPrimitives::numberOfMethodInvocations),
02666 65536,
02667 signature_266,
02668 errors_266
02669 };
02670
02671 static char* signature_267[] = { "SmallInteger"};
02672 static char* errors_267[] = {NULL};
02673 static primitive_desc primitive_267 = {
02674 "primitiveNumberOfNMethodInvocations",
02675 fntype(&debugPrimitives::numberOfNMethodInvocations),
02676 65536,
02677 signature_267,
02678 errors_267
02679 };
02680
02681 static char* signature_268[] = { "SmallInteger"};
02682 static char* errors_268[] = {NULL};
02683 static primitive_desc primitive_268 = {
02684 "primitiveNumberOfPrimaryLookupCacheHits",
02685 fntype(&debugPrimitives::numberOfPrimaryLookupCacheHits),
02686 65536,
02687 signature_268,
02688 errors_268
02689 };
02690
02691 static char* signature_269[] = { "SmallInteger"};
02692 static char* errors_269[] = {NULL};
02693 static primitive_desc primitive_269 = {
02694 "primitiveNumberOfSecondaryLookupCacheHits",
02695 fntype(&debugPrimitives::numberOfSecondaryLookupCacheHits),
02696 65536,
02697 signature_269,
02698 errors_269
02699 };
02700
02701 static char* signature_270[] = { "SmallInteger", "Object"};
02702 static char* errors_270[] = {NULL};
02703 static primitive_desc primitive_270 = {
02704 "primitiveOopSize",
02705 fntype(&oopPrimitives::oop_size),
02706 1572865,
02707 signature_270,
02708 errors_270
02709 };
02710
02711 static char* signature_271[] = { "Object", "Object", "Symbol"};
02712 static char* errors_271[] = { "NotFound", NULL};
02713 static primitive_desc primitive_271 = {
02714 "primitiveOptimizeMethod:ifFail:",
02715 fntype(&debugPrimitives::optimizeMethod),
02716 1376258,
02717 signature_271,
02718 errors_271
02719 };
02720
02721 static char* signature_272[] = { "Object", "Object", "CompressedSymbol", "Array"};
02722 static char* errors_272[] = { "SelectorHasWrongNumberOfArguments", NULL};
02723 static primitive_desc primitive_272 = {
02724 "primitivePerform:arguments:ifFail:",
02725 fntype(&oopPrimitives::performArguments),
02726 1507331,
02727 signature_272,
02728 errors_272
02729 };
02730
02731 static char* signature_273[] = { "Object", "Object", "CompressedSymbol"};
02732 static char* errors_273[] = { "SelectorHasWrongNumberOfArguments", NULL};
02733 static primitive_desc primitive_273 = {
02734 "primitivePerform:ifFail:",
02735 fntype(&oopPrimitives::perform),
02736 1376258,
02737 signature_273,
02738 errors_273
02739 };
02740
02741 static char* signature_274[] = { "Object", "Object", "CompressedSymbol", "Object"};
02742 static char* errors_274[] = { "SelectorHasWrongNumberOfArguments", NULL};
02743 static primitive_desc primitive_274 = {
02744 "primitivePerform:with:ifFail:",
02745 fntype(&oopPrimitives::performWith),
02746 1507331,
02747 signature_274,
02748 errors_274
02749 };
02750
02751 static char* signature_275[] = { "Object", "Object", "CompressedSymbol", "Object", "Object"};
02752 static char* errors_275[] = { "SelectorHasWrongNumberOfArguments", NULL};
02753 static primitive_desc primitive_275 = {
02754 "primitivePerform:with:with:ifFail:",
02755 fntype(&oopPrimitives::performWithWith),
02756 1507332,
02757 signature_275,
02758 errors_275
02759 };
02760
02761 static char* signature_276[] = { "Object", "Object", "CompressedSymbol", "Object", "Object", "Object"};
02762 static char* errors_276[] = { "SelectorHasWrongNumberOfArguments", NULL};
02763 static primitive_desc primitive_276 = {
02764 "primitivePerform:with:with:with:ifFail:",
02765 fntype(&oopPrimitives::performWithWithWith),
02766 1507333,
02767 signature_276,
02768 errors_276
02769 };
02770
02771 static char* signature_277[] = { "Self", "Object"};
02772 static char* errors_277[] = {NULL};
02773 static primitive_desc primitive_277 = {
02774 "primitivePrint",
02775 fntype(&oopPrimitives::print),
02776 1114113,
02777 signature_277,
02778 errors_277
02779 };
02780
02781 static char* signature_278[] = { "SmallInteger", "SmallInteger"};
02782 static char* errors_278[] = { "OutOfBounds", NULL};
02783 static primitive_desc primitive_278 = {
02784 "primitivePrintCharacterIfFail:",
02785 fntype(&smiOopPrimitives::printCharacter),
02786 1310721,
02787 signature_278,
02788 errors_278
02789 };
02790
02791 static char* signature_279[] = { "Object", "SmallInteger"};
02792 static char* errors_279[] = {NULL};
02793 static primitive_desc primitive_279 = {
02794 "primitivePrintInvocationCounterHistogram:ifFail:",
02795 fntype(&debugPrimitives::printInvocationCounterHistogram),
02796 327681,
02797 signature_279,
02798 errors_279
02799 };
02800
02801 static char* signature_280[] = { "Object"};
02802 static char* errors_280[] = {NULL};
02803 static primitive_desc primitive_280 = {
02804 "primitivePrintLayout",
02805 fntype(&debugPrimitives::printMemoryLayout),
02806 65536,
02807 signature_280,
02808 errors_280
02809 };
02810
02811 static char* signature_281[] = { "Object"};
02812 static char* errors_281[] = {NULL};
02813 static primitive_desc primitive_281 = {
02814 "primitivePrintLookupCacheStatistics",
02815 fntype(&debugPrimitives::printLookupCacheStatistics),
02816 65536,
02817 signature_281,
02818 errors_281
02819 };
02820
02821 static char* signature_282[] = { "Object"};
02822 static char* errors_282[] = {NULL};
02823 static primitive_desc primitive_282 = {
02824 "primitivePrintMemory",
02825 fntype(&systemPrimitives::print_memory),
02826 65536,
02827 signature_282,
02828 errors_282
02829 };
02830
02831 static char* signature_283[] = { "Behavior", "Behavior", "ByteArray"};
02832 static char* errors_283[] = {NULL};
02833 static primitive_desc primitive_283 = {
02834 "primitivePrintMethod:ifFail:",
02835 fntype(&behaviorPrimitives::printMethod),
02836 1376258,
02837 signature_283,
02838 errors_283
02839 };
02840
02841 static char* signature_284[] = { "Object", "Object", "Symbol"};
02842 static char* errors_284[] = { "NotFound", NULL};
02843 static primitive_desc primitive_284 = {
02844 "primitivePrintMethodCodes:ifFail:",
02845 fntype(&debugPrimitives::printMethodCodes),
02846 1376258,
02847 signature_284,
02848 errors_284
02849 };
02850
02851 static char* signature_285[] = { "Object", "SmallInteger"};
02852 static char* errors_285[] = {NULL};
02853 static primitive_desc primitive_285 = {
02854 "primitivePrintNMethodCounterHistogram:ifFail:",
02855 fntype(&debugPrimitives::printNMethodCounterHistogram),
02856 327681,
02857 signature_285,
02858 errors_285
02859 };
02860
02861 static char* signature_286[] = { "Object"};
02862 static char* errors_286[] = {NULL};
02863 static primitive_desc primitive_286 = {
02864 "primitivePrintObjectHistogram",
02865 fntype(&debugPrimitives::printObjectHistogram),
02866 65536,
02867 signature_286,
02868 errors_286
02869 };
02870
02871 static char* signature_287[] = { "Object"};
02872 static char* errors_287[] = {NULL};
02873 static primitive_desc primitive_287 = {
02874 "primitivePrintPrimitiveCounters",
02875 fntype(&debugPrimitives::printPrimitiveCounters),
02876 65536,
02877 signature_287,
02878 errors_287
02879 };
02880
02881 static char* signature_288[] = { "Object"};
02882 static char* errors_288[] = {NULL};
02883 static primitive_desc primitive_288 = {
02884 "primitivePrintPrimitiveTable",
02885 fntype(&systemPrimitives::printPrimitiveTable),
02886 65536,
02887 signature_288,
02888 errors_288
02889 };
02890
02891 static char* signature_289[] = { "Self", "Object"};
02892 static char* errors_289[] = {NULL};
02893 static primitive_desc primitive_289 = {
02894 "primitivePrintValue",
02895 fntype(&oopPrimitives::printValue),
02896 1114113,
02897 signature_289,
02898 errors_289
02899 };
02900
02901 static char* signature_290[] = { "Object"};
02902 static char* errors_290[] = {NULL};
02903 static primitive_desc primitive_290 = {
02904 "primitivePrintZone",
02905 fntype(&systemPrimitives::print_zone),
02906 65536,
02907 signature_290,
02908 errors_290
02909 };
02910
02911 static char* signature_291[] = { "Object"};
02912 static char* errors_291[] = {NULL};
02913 static primitive_desc primitive_291 = {
02914 "primitiveProcessActiveProcess",
02915 fntype(&processOopPrimitives::activeProcess),
02916 65536,
02917 signature_291,
02918 errors_291
02919 };
02920
02921 static char* signature_292[] = { "Process", "Process class", "BlockWithoutArguments"};
02922 static char* errors_292[] = { "ProcessAllocationFailed", NULL};
02923 static primitive_desc primitive_292 = {
02924 "primitiveProcessCreate:ifFail:",
02925 fntype(&processOopPrimitives::create),
02926 1376258,
02927 signature_292,
02928 errors_292
02929 };
02930
02931 static char* signature_293[] = { "Process"};
02932 static char* errors_293[] = {NULL};
02933 static primitive_desc primitive_293 = {
02934 "primitiveProcessEnterCritical",
02935 fntype(&processOopPrimitives::enter_critical),
02936 65536,
02937 signature_293,
02938 errors_293
02939 };
02940
02941 static char* signature_294[] = { "Process"};
02942 static char* errors_294[] = {NULL};
02943 static primitive_desc primitive_294 = {
02944 "primitiveProcessLeaveCritical",
02945 fntype(&processOopPrimitives::leave_critical),
02946 65536,
02947 signature_294,
02948 errors_294
02949 };
02950
02951 static char* signature_295[] = { "Boolean", "Process", "SmallInteger"};
02952 static char* errors_295[] = {NULL};
02953 static primitive_desc primitive_295 = {
02954 "primitiveProcessSchedulerWait:ifFail:",
02955 fntype(&processOopPrimitives::scheduler_wait),
02956 1376258,
02957 signature_295,
02958 errors_295
02959 };
02960
02961 static char* signature_296[] = { "Symbol", "Process", "Symbol", "Activation", "Object"};
02962 static char* errors_296[] = { "InScheduler", "Dead", NULL};
02963 static primitive_desc primitive_296 = {
02964 "primitiveProcessSetMode:activation:returnValue:ifFail:",
02965 fntype(&processOopPrimitives::set_mode),
02966 1376260,
02967 signature_296,
02968 errors_296
02969 };
02970
02971 static char* signature_297[] = { "IndexedInstanceVariables", "Process", "SmallInteger"};
02972 static char* errors_297[] = {NULL};
02973 static primitive_desc primitive_297 = {
02974 "primitiveProcessStackLimit:ifFail:",
02975 fntype(&processOopPrimitives::stack),
02976 1376258,
02977 signature_297,
02978 errors_297
02979 };
02980
02981 static char* signature_298[] = { "Object", "Process"};
02982 static char* errors_298[] = { "NotInScheduler", "ProcessCannotContinue", "Dead", NULL};
02983 static primitive_desc primitive_298 = {
02984 "primitiveProcessStartEvaluator:ifFail:",
02985 fntype(&processOopPrimitives::start_evaluator),
02986 327681,
02987 signature_298,
02988 errors_298
02989 };
02990
02991 static char* signature_299[] = { "Symbol", "Process"};
02992 static char* errors_299[] = {NULL};
02993 static primitive_desc primitive_299 = {
02994 "primitiveProcessStatus",
02995 fntype(&processOopPrimitives::status),
02996 1114113,
02997 signature_299,
02998 errors_299
02999 };
03000
03001 static char* signature_300[] = { "Process"};
03002 static char* errors_300[] = {NULL};
03003 static primitive_desc primitive_300 = {
03004 "primitiveProcessStop",
03005 fntype(&processOopPrimitives::stop),
03006 65536,
03007 signature_300,
03008 errors_300
03009 };
03010
03011 static char* signature_301[] = { "Float", "Process"};
03012 static char* errors_301[] = {NULL};
03013 static primitive_desc primitive_301 = {
03014 "primitiveProcessSystemTime",
03015 fntype(&processOopPrimitives::user_time),
03016 1114113,
03017 signature_301,
03018 errors_301
03019 };
03020
03021 static char* signature_302[] = { "Self", "Process"};
03022 static char* errors_302[] = { "Dead", NULL};
03023 static primitive_desc primitive_302 = {
03024 "primitiveProcessTerminateIfFail:",
03025 fntype(&processOopPrimitives::terminate),
03026 1507329,
03027 signature_302,
03028 errors_302
03029 };
03030
03031 static char* signature_303[] = { "Self", "Process", "SmallInteger"};
03032 static char* errors_303[] = {NULL};
03033 static primitive_desc primitive_303 = {
03034 "primitiveProcessTraceStack:ifFail:",
03035 fntype(&processOopPrimitives::trace_stack),
03036 1376258,
03037 signature_303,
03038 errors_303
03039 };
03040
03041 static char* signature_304[] = { "Object", "Process"};
03042 static char* errors_304[] = { "NotInScheduler", "ProcessCannotContinue", "Dead", NULL};
03043 static primitive_desc primitive_304 = {
03044 "primitiveProcessTransferTo:ifFail:",
03045 fntype(&processOopPrimitives::transferTo),
03046 327681,
03047 signature_304,
03048 errors_304
03049 };
03050
03051 static char* signature_305[] = { "Float", "Process"};
03052 static char* errors_305[] = {NULL};
03053 static primitive_desc primitive_305 = {
03054 "primitiveProcessUserTime",
03055 fntype(&processOopPrimitives::user_time),
03056 1114113,
03057 signature_305,
03058 errors_305
03059 };
03060
03061 static char* signature_306[] = { "Process"};
03062 static char* errors_306[] = {NULL};
03063 static primitive_desc primitive_306 = {
03064 "primitiveProcessYield",
03065 fntype(&processOopPrimitives::yield),
03066 65536,
03067 signature_306,
03068 errors_306
03069 };
03070
03071 static char* signature_307[] = { "Process"};
03072 static char* errors_307[] = {NULL};
03073 static primitive_desc primitive_307 = {
03074 "primitiveProcessYieldInCritical",
03075 fntype(&processOopPrimitives::yield_in_critical),
03076 65536,
03077 signature_307,
03078 errors_307
03079 };
03080
03081 static char* signature_308[] = { "SmallInteger", "Proxy", "SmallInteger"};
03082 static char* errors_308[] = {NULL};
03083 static primitive_desc primitive_308 = {
03084 "primitiveProxyByteAt:ifFail:",
03085 fntype(&proxyOopPrimitives::byteAt),
03086 5570562,
03087 signature_308,
03088 errors_308
03089 };
03090
03091 static char* signature_309[] = { "SmallInteger", "Proxy", "SmallInteger", "SmallInteger"};
03092 static char* errors_309[] = {NULL};
03093 static primitive_desc primitive_309 = {
03094 "primitiveProxyByteAt:put:ifFail:",
03095 fntype(&proxyOopPrimitives::byteAtPut),
03096 5570563,
03097 signature_309,
03098 errors_309
03099 };
03100
03101 static char* signature_310[] = { "Self", "Proxy", "SmallInteger"};
03102 static char* errors_310[] = {NULL};
03103 static primitive_desc primitive_310 = {
03104 "primitiveProxyCalloc:ifFail:",
03105 fntype(&proxyOopPrimitives::calloc),
03106 1376258,
03107 signature_310,
03108 errors_310
03109 };
03110
03111 static char* signature_311[] = { "SmallInteger", "Proxy", "SmallInteger"};
03112 static char* errors_311[] = {NULL};
03113 static primitive_desc primitive_311 = {
03114 "primitiveProxyDoubleByteAt:ifFail:",
03115 fntype(&proxyOopPrimitives::doubleByteAt),
03116 1376258,
03117 signature_311,
03118 errors_311
03119 };
03120
03121 static char* signature_312[] = { "SmallInteger", "Proxy", "SmallInteger", "SmallInteger"};
03122 static char* errors_312[] = {NULL};
03123 static primitive_desc primitive_312 = {
03124 "primitiveProxyDoubleByteAt:put:ifFail:",
03125 fntype(&proxyOopPrimitives::doubleByteAtPut),
03126 1376259,
03127 signature_312,
03128 errors_312
03129 };
03130
03131 static char* signature_313[] = { "Float", "Proxy", "SmallInteger"};
03132 static char* errors_313[] = {NULL};
03133 static primitive_desc primitive_313 = {
03134 "primitiveProxyDoublePrecisionFloatAt:ifFail:",
03135 fntype(&proxyOopPrimitives::doublePrecisionFloatAt),
03136 1376258,
03137 signature_313,
03138 errors_313
03139 };
03140
03141 static char* signature_314[] = { "Self", "Proxy", "SmallInteger", "Float"};
03142 static char* errors_314[] = { "ConversionFailed", NULL};
03143 static primitive_desc primitive_314 = {
03144 "primitiveProxyDoublePrecisionFloatAt:put:ifFail:",
03145 fntype(&proxyOopPrimitives::doublePrecisionFloatAtPut),
03146 1376259,
03147 signature_314,
03148 errors_314
03149 };
03150
03151 static char* signature_315[] = { "Self", "Proxy"};
03152 static char* errors_315[] = {NULL};
03153 static primitive_desc primitive_315 = {
03154 "primitiveProxyFree",
03155 fntype(&proxyOopPrimitives::free),
03156 1114113,
03157 signature_315,
03158 errors_315
03159 };
03160
03161 static char* signature_316[] = { "SmallInteger", "Proxy"};
03162 static char* errors_316[] = {NULL};
03163 static primitive_desc primitive_316 = {
03164 "primitiveProxyGetHigh",
03165 fntype(&proxyOopPrimitives::getHigh),
03166 1114113,
03167 signature_316,
03168 errors_316
03169 };
03170
03171 static char* signature_317[] = { "SmallInteger", "Proxy"};
03172 static char* errors_317[] = { "ConversionFailed", NULL};
03173 static primitive_desc primitive_317 = {
03174 "primitiveProxyGetIfFail:",
03175 fntype(&proxyOopPrimitives::getSmi),
03176 1376257,
03177 signature_317,
03178 errors_317
03179 };
03180
03181 static char* signature_318[] = { "SmallInteger", "Proxy"};
03182 static char* errors_318[] = {NULL};
03183 static primitive_desc primitive_318 = {
03184 "primitiveProxyGetLow",
03185 fntype(&proxyOopPrimitives::getLow),
03186 1114113,
03187 signature_318,
03188 errors_318
03189 };
03190
03191 static char* signature_319[] = { "Boolean", "Proxy"};
03192 static char* errors_319[] = {NULL};
03193 static primitive_desc primitive_319 = {
03194 "primitiveProxyIsAllOnes",
03195 fntype(&proxyOopPrimitives::isAllOnes),
03196 1114113,
03197 signature_319,
03198 errors_319
03199 };
03200
03201 static char* signature_320[] = { "Boolean", "Proxy"};
03202 static char* errors_320[] = {NULL};
03203 static primitive_desc primitive_320 = {
03204 "primitiveProxyIsNull",
03205 fntype(&proxyOopPrimitives::isNull),
03206 1114113,
03207 signature_320,
03208 errors_320
03209 };
03210
03211 static char* signature_321[] = { "Self", "Proxy", "SmallInteger"};
03212 static char* errors_321[] = {NULL};
03213 static primitive_desc primitive_321 = {
03214 "primitiveProxyMalloc:ifFail:",
03215 fntype(&proxyOopPrimitives::malloc),
03216 1376258,
03217 signature_321,
03218 errors_321
03219 };
03220
03221 static char* signature_322[] = { "Proxy", "Proxy", "SmallInteger", "Proxy"};
03222 static char* errors_322[] = {NULL};
03223 static primitive_desc primitive_322 = {
03224 "primitiveProxyProxyAt:put:ifFail:",
03225 fntype(&proxyOopPrimitives::proxyAtPut),
03226 1376259,
03227 signature_322,
03228 errors_322
03229 };
03230
03231 static char* signature_323[] = { "Proxy", "Proxy", "SmallInteger", "Proxy"};
03232 static char* errors_323[] = {NULL};
03233 static primitive_desc primitive_323 = {
03234 "primitiveProxyProxyAt:result:ifFail:",
03235 fntype(&proxyOopPrimitives::proxyAt),
03236 1376259,
03237 signature_323,
03238 errors_323
03239 };
03240
03241 static char* signature_324[] = { "Self", "Proxy", "SmallInteger|Proxy"};
03242 static char* errors_324[] = {NULL};
03243 static primitive_desc primitive_324 = {
03244 "primitiveProxySet:ifFail:",
03245 fntype(&proxyOopPrimitives::set),
03246 1376258,
03247 signature_324,
03248 errors_324
03249 };
03250
03251 static char* signature_325[] = { "Self", "Proxy", "SmallInteger", "SmallInteger"};
03252 static char* errors_325[] = {NULL};
03253 static primitive_desc primitive_325 = {
03254 "primitiveProxySetHigh:low:ifFail:",
03255 fntype(&proxyOopPrimitives::setHighLow),
03256 1376259,
03257 signature_325,
03258 errors_325
03259 };
03260
03261 static char* signature_326[] = { "Float", "Proxy", "SmallInteger"};
03262 static char* errors_326[] = {NULL};
03263 static primitive_desc primitive_326 = {
03264 "primitiveProxySinglePrecisionFloatAt:ifFail:",
03265 fntype(&proxyOopPrimitives::singlePrecisionFloatAt),
03266 1376258,
03267 signature_326,
03268 errors_326
03269 };
03270
03271 static char* signature_327[] = { "Self", "Proxy", "SmallInteger", "Float"};
03272 static char* errors_327[] = { "ConversionFailed", NULL};
03273 static primitive_desc primitive_327 = {
03274 "primitiveProxySinglePrecisionFloatAt:put:ifFail:",
03275 fntype(&proxyOopPrimitives::singlePrecisionFloatAtPut),
03276 1376259,
03277 signature_327,
03278 errors_327
03279 };
03280
03281 static char* signature_328[] = { "SmallInteger", "Proxy", "SmallInteger"};
03282 static char* errors_328[] = { "ConversionFailed", NULL};
03283 static primitive_desc primitive_328 = {
03284 "primitiveProxySmiAt:ifFail:",
03285 fntype(&proxyOopPrimitives::smiAt),
03286 1376258,
03287 signature_328,
03288 errors_328
03289 };
03290
03291 static char* signature_329[] = { "SmallInteger", "Proxy", "SmallInteger", "SmallInteger"};
03292 static char* errors_329[] = {NULL};
03293 static primitive_desc primitive_329 = {
03294 "primitiveProxySmiAt:put:ifFail:",
03295 fntype(&proxyOopPrimitives::smiAtPut),
03296 1376259,
03297 signature_329,
03298 errors_329
03299 };
03300
03301 static char* signature_330[] = { "Proxy", "Proxy", "SmallInteger", "Proxy"};
03302 static char* errors_330[] = {NULL};
03303 static primitive_desc primitive_330 = {
03304 "primitiveProxySubProxyAt:result:ifFail:",
03305 fntype(&proxyOopPrimitives::subProxyAt),
03306 1376259,
03307 signature_330,
03308 errors_330
03309 };
03310
03311 static char* signature_331[] = { "BottomType"};
03312 static char* errors_331[] = {NULL};
03313 static primitive_desc primitive_331 = {
03314 "primitiveQuit",
03315 fntype(&systemPrimitives::quit),
03316 65536,
03317 signature_331,
03318 errors_331
03319 };
03320
03321 static char* signature_332[] = { "SmallInteger", "SmallInteger", "SmallInteger"};
03322 static char* errors_332[] = { "NotImplementedYet", NULL};
03323 static primitive_desc primitive_332 = {
03324 "primitiveQuo:ifFail:",
03325 fntype(&smiOopPrimitives_quo),
03326 6029826,
03327 signature_332,
03328 errors_332
03329 };
03330
03331 static char* signature_333[] = { "SmallInteger", "SmallInteger", "SmallInteger"};
03332 static char* errors_333[] = {NULL};
03333 static primitive_desc primitive_333 = {
03334 "primitiveRawBitShift:ifFail:",
03335 fntype(&smiOopPrimitives::rawBitShift),
03336 6029826,
03337 signature_333,
03338 errors_333
03339 };
03340
03341 static char* signature_334[] = { "IndexedInstanceVariables", "Object", "SmallInteger"};
03342 static char* errors_334[] = {NULL};
03343 static primitive_desc primitive_334 = {
03344 "primitiveReferencesTo:limit:ifFail:",
03345 fntype(&systemPrimitives::references_to),
03346 327682,
03347 signature_334,
03348 errors_334
03349 };
03350
03351 static char* signature_335[] = { "IndexedInstanceVariables", "Class", "SmallInteger"};
03352 static char* errors_335[] = {NULL};
03353 static primitive_desc primitive_335 = {
03354 "primitiveReferencesToInstancesOf:limit:ifFail:",
03355 fntype(&systemPrimitives::references_to_instances_of),
03356 327682,
03357 signature_335,
03358 errors_335
03359 };
03360
03361 static char* signature_336[] = { "SmallInteger", "SmallInteger", "SmallInteger"};
03362 static char* errors_336[] = { "DivisionByZero", NULL};
03363 static primitive_desc primitive_336 = {
03364 "primitiveRemainder:ifFail:",
03365 fntype(&smiOopPrimitives_remainder),
03366 6029826,
03367 signature_336,
03368 errors_336
03369 };
03370
03371 static char* signature_337[] = { "BottomType", "BlockWithoutArguments"};
03372 static char* errors_337[] = {NULL};
03373 static primitive_desc primitive_337 = {
03374 "primitiveRepeat",
03375 fntype(&blockRepeat),
03376 1245185,
03377 signature_337,
03378 errors_337
03379 };
03380
03381 static char* signature_338[] = { "Self", "Object"};
03382 static char* errors_338[] = {NULL};
03383 static primitive_desc primitive_338 = {
03384 "primitiveScavenge",
03385 fntype(&systemPrimitives::scavenge),
03386 1114113,
03387 signature_338,
03388 errors_338
03389 };
03390
03391 static char* signature_339[] = { "Object", "SmallInteger"};
03392 static char* errors_339[] = {NULL};
03393 static primitive_desc primitive_339 = {
03394 "primitiveSetInterpreterInvocationCounterLimitTo:ifFail:",
03395 fntype(&debugPrimitives::setInterpreterInvocationCounterLimit),
03396 327681,
03397 signature_339,
03398 errors_339
03399 };
03400
03401 static char* signature_340[] = { "Object", "Object"};
03402 static char* errors_340[] = { "ReceiverHasWrongType", NULL};
03403 static primitive_desc primitive_340 = {
03404 "primitiveShallowCopyIfFail:",
03405 fntype(&oopPrimitives::shallowCopy),
03406 1376257,
03407 signature_340,
03408 errors_340
03409 };
03410
03411 static char* signature_341[] = { "IndexedInstanceVariables"};
03412 static char* errors_341[] = {NULL};
03413 static primitive_desc primitive_341 = {
03414 "primitiveSlidingSystemAverageIfFail:",
03415 fntype(&systemPrimitives::sliding_system_average),
03416 327680,
03417 signature_341,
03418 errors_341
03419 };
03420
03421 static char* signature_342[] = { "Boolean", "SmallInteger", "SmallInteger"};
03422 static char* errors_342[] = {NULL};
03423 static primitive_desc primitive_342 = {
03424 "primitiveSmallIntegerEqual:ifFail:",
03425 fntype(&smiOopPrimitives::equal),
03426 6029570,
03427 signature_342,
03428 errors_342
03429 };
03430
03431 static char* signature_343[] = { "SmallInteger", "Symbol"};
03432 static char* errors_343[] = { "NotFound", NULL};
03433 static primitive_desc primitive_343 = {
03434 "primitiveSmallIntegerFlagAt:ifFail:",
03435 fntype(&debugPrimitives::smiAt),
03436 327681,
03437 signature_343,
03438 errors_343
03439 };
03440
03441 static char* signature_344[] = { "Boolean", "Symbol", "Boolean"};
03442 static char* errors_344[] = { "NotFound", NULL};
03443 static primitive_desc primitive_344 = {
03444 "primitiveSmallIntegerFlagAt:put:ifFail:",
03445 fntype(&debugPrimitives::smiAtPut),
03446 327682,
03447 signature_344,
03448 errors_344
03449 };
03450
03451 static char* signature_345[] = { "Boolean", "SmallInteger", "SmallInteger"};
03452 static char* errors_345[] = {NULL};
03453 static primitive_desc primitive_345 = {
03454 "primitiveSmallIntegerNotEqual:ifFail:",
03455 fntype(&smiOopPrimitives::notEqual),
03456 6029570,
03457 signature_345,
03458 errors_345
03459 };
03460
03461 static char* signature_346[] = { "IndexedInstanceVariables"};
03462 static char* errors_346[] = {NULL};
03463 static primitive_desc primitive_346 = {
03464 "primitiveSmalltalkArray",
03465 fntype(&systemPrimitives::smalltalk_array),
03466 65536,
03467 signature_346,
03468 errors_346
03469 };
03470
03471 static char* signature_347[] = { "GlobalAssociation", "Symbol", "Object"};
03472 static char* errors_347[] = {NULL};
03473 static primitive_desc primitive_347 = {
03474 "primitiveSmalltalkAt:Put:ifFail:",
03475 fntype(&systemPrimitives::smalltalk_at_put),
03476 327682,
03477 signature_347,
03478 errors_347
03479 };
03480
03481 static char* signature_348[] = { "GlobalAssociation", "SmallInteger"};
03482 static char* errors_348[] = { "OutOfBounds", NULL};
03483 static primitive_desc primitive_348 = {
03484 "primitiveSmalltalkAt:ifFail:",
03485 fntype(&systemPrimitives::smalltalk_at),
03486 327681,
03487 signature_348,
03488 errors_348
03489 };
03490
03491 static char* signature_349[] = { "GlobalAssociation", "SmallInteger"};
03492 static char* errors_349[] = {NULL};
03493 static primitive_desc primitive_349 = {
03494 "primitiveSmalltalkRemoveAt:ifFail:",
03495 fntype(&systemPrimitives::smalltalk_remove_at),
03496 327681,
03497 signature_349,
03498 errors_349
03499 };
03500
03501 static char* signature_350[] = { "SmallInteger"};
03502 static char* errors_350[] = {NULL};
03503 static primitive_desc primitive_350 = {
03504 "primitiveSmalltalkSize",
03505 fntype(&systemPrimitives::smalltalk_size),
03506 65536,
03507 signature_350,
03508 errors_350
03509 };
03510
03511 static char* signature_351[] = { "SmallInteger", "SmallInteger", "SmallInteger"};
03512 static char* errors_351[] = { "Overflow", NULL};
03513 static primitive_desc primitive_351 = {
03514 "primitiveSubtract:ifFail:",
03515 fntype(&smiOopPrimitives_subtract),
03516 6029826,
03517 signature_351,
03518 errors_351
03519 };
03520
03521 static char* signature_352[] = { "Behavior|Nil", "Behavior"};
03522 static char* errors_352[] = {NULL};
03523 static primitive_desc primitive_352 = {
03524 "primitiveSuperclass",
03525 fntype(&behaviorPrimitives::superclass),
03526 1114113,
03527 signature_352,
03528 errors_352
03529 };
03530
03531 static char* signature_353[] = { "Behavior|Nil", "Behavior"};
03532 static char* errors_353[] = {NULL};
03533 static primitive_desc primitive_353 = {
03534 "primitiveSuperclassOf:ifFail:",
03535 fntype(&behaviorPrimitives::superclass_of),
03536 327681,
03537 signature_353,
03538 errors_353
03539 };
03540
03541 static char* signature_354[] = { "Float"};
03542 static char* errors_354[] = {NULL};
03543 static primitive_desc primitive_354 = {
03544 "primitiveSystemTime",
03545 fntype(&systemPrimitives::systemTime),
03546 65536,
03547 signature_354,
03548 errors_354
03549 };
03550
03551 static char* signature_355[] = { "Object"};
03552 static char* errors_355[] = {NULL};
03553 static primitive_desc primitive_355 = {
03554 "primitiveTimerPrintBuffer",
03555 fntype(&debugPrimitives::timerPrintBuffer),
03556 65536,
03557 signature_355,
03558 errors_355
03559 };
03560
03561 static char* signature_356[] = { "Object"};
03562 static char* errors_356[] = {NULL};
03563 static primitive_desc primitive_356 = {
03564 "primitiveTimerStart",
03565 fntype(&debugPrimitives::timerStart),
03566 65536,
03567 signature_356,
03568 errors_356
03569 };
03570
03571 static char* signature_357[] = { "Object"};
03572 static char* errors_357[] = {NULL};
03573 static primitive_desc primitive_357 = {
03574 "primitiveTimerStop",
03575 fntype(&debugPrimitives::timerStop),
03576 65536,
03577 signature_357,
03578 errors_357
03579 };
03580
03581 static char* signature_358[] = { "Object"};
03582 static char* errors_358[] = {NULL};
03583 static primitive_desc primitive_358 = {
03584 "primitiveTraceStack",
03585 fntype(&systemPrimitives::traceStack),
03586 65536,
03587 signature_358,
03588 errors_358
03589 };
03590
03591 static char* signature_359[] = { "Object", "BlockWithoutArguments", "BlockWithoutArguments"};
03592 static char* errors_359[] = {NULL};
03593 static primitive_desc primitive_359 = {
03594 "primitiveUnwindProtect:ifFail:",
03595 fntype(&unwindprotect),
03596 1507330,
03597 signature_359,
03598 errors_359
03599 };
03600
03601 static char* signature_360[] = { "Float"};
03602 static char* errors_360[] = {NULL};
03603 static primitive_desc primitive_360 = {
03604 "primitiveUserTime",
03605 fntype(&systemPrimitives::userTime),
03606 65536,
03607 signature_360,
03608 errors_360
03609 };
03610
03611 static char* signature_361[] = { "Object", "BlockWithoutArguments"};
03612 static char* errors_361[] = {NULL};
03613 static primitive_desc primitive_361 = {
03614 "primitiveValue",
03615 fntype(&primitiveValue0),
03616 5441537,
03617 signature_361,
03618 errors_361
03619 };
03620
03621 static char* signature_362[] = { "Object", "BlockWithOneArgument", "Object"};
03622 static char* errors_362[] = {NULL};
03623 static primitive_desc primitive_362 = {
03624 "primitiveValue:",
03625 fntype(&primitiveValue1),
03626 5441538,
03627 signature_362,
03628 errors_362
03629 };
03630
03631 static char* signature_363[] = { "Object", "BlockWithTwoArguments", "Object", "Object"};
03632 static char* errors_363[] = {NULL};
03633 static primitive_desc primitive_363 = {
03634 "primitiveValue:value:",
03635 fntype(&primitiveValue2),
03636 5441539,
03637 signature_363,
03638 errors_363
03639 };
03640
03641 static char* signature_364[] = { "Object", "BlockWithThreeArguments", "Object", "Object", "Object"};
03642 static char* errors_364[] = {NULL};
03643 static primitive_desc primitive_364 = {
03644 "primitiveValue:value:value:",
03645 fntype(&primitiveValue3),
03646 5441540,
03647 signature_364,
03648 errors_364
03649 };
03650
03651 static char* signature_365[] = { "Object", "BlockWithFourArguments", "Object", "Object", "Object", "Object"};
03652 static char* errors_365[] = {NULL};
03653 static primitive_desc primitive_365 = {
03654 "primitiveValue:value:value:value:",
03655 fntype(&primitiveValue4),
03656 5441541,
03657 signature_365,
03658 errors_365
03659 };
03660
03661 static char* signature_366[] = { "Object", "BlockWithFiveArguments", "Object", "Object", "Object", "Object", "Object"};
03662 static char* errors_366[] = {NULL};
03663 static primitive_desc primitive_366 = {
03664 "primitiveValue:value:value:value:value:",
03665 fntype(&primitiveValue5),
03666 5441542,
03667 signature_366,
03668 errors_366
03669 };
03670
03671 static char* signature_367[] = { "Object", "BlockWithSixArguments", "Object", "Object", "Object", "Object", "Object", "Object"};
03672 static char* errors_367[] = {NULL};
03673 static primitive_desc primitive_367 = {
03674 "primitiveValue:value:value:value:value:value:",
03675 fntype(&primitiveValue6),
03676 5441543,
03677 signature_367,
03678 errors_367
03679 };
03680
03681 static char* signature_368[] = { "Object", "BlockWithSevenArguments", "Object", "Object", "Object", "Object", "Object", "Object", "Object"};
03682 static char* errors_368[] = {NULL};
03683 static primitive_desc primitive_368 = {
03684 "primitiveValue:value:value:value:value:value:value:",
03685 fntype(&primitiveValue7),
03686 5441544,
03687 signature_368,
03688 errors_368
03689 };
03690
03691 static char* signature_369[] = { "Object", "BlockWithEightArguments", "Object", "Object", "Object", "Object", "Object", "Object", "Object", "Object"};
03692 static char* errors_369[] = {NULL};
03693 static primitive_desc primitive_369 = {
03694 "primitiveValue:value:value:value:value:value:value:value:",
03695 fntype(&primitiveValue8),
03696 5441545,
03697 signature_369,
03698 errors_369
03699 };
03700
03701 static char* signature_370[] = { "Object", "BlockWithNineArguments", "Object", "Object", "Object", "Object", "Object", "Object", "Object", "Object", "Object"};
03702 static char* errors_370[] = {NULL};
03703 static primitive_desc primitive_370 = {
03704 "primitiveValue:value:value:value:value:value:value:value:value:",
03705 fntype(&primitiveValue9),
03706 5441546,
03707 signature_370,
03708 errors_370
03709 };
03710
03711 static char* signature_371[] = { "Object"};
03712 static char* errors_371[] = {NULL};
03713 static primitive_desc primitive_371 = {
03714 "primitiveVerify",
03715 fntype(&debugPrimitives::verify),
03716 65536,
03717 signature_371,
03718 errors_371
03719 };
03720
03721 static char* signature_372[] = { "Proxy", "Proxy"};
03722 static char* errors_372[] = {NULL};
03723 static primitive_desc primitive_372 = {
03724 "primitiveWindowsHInstance:ifFail:",
03725 fntype(&systemPrimitives::windowsHInstance),
03726 327681,
03727 signature_372,
03728 errors_372
03729 };
03730
03731 static char* signature_373[] = { "Proxy", "Proxy"};
03732 static char* errors_373[] = {NULL};
03733 static primitive_desc primitive_373 = {
03734 "primitiveWindowsHPrevInstance:ifFail:",
03735 fntype(&systemPrimitives::windowsHPrevInstance),
03736 327681,
03737 signature_373,
03738 errors_373
03739 };
03740
03741 static char* signature_374[] = { "Object"};
03742 static char* errors_374[] = {NULL};
03743 static primitive_desc primitive_374 = {
03744 "primitiveWindowsNCmdShow",
03745 fntype(&systemPrimitives::windowsNCmdShow),
03746 65536,
03747 signature_374,
03748 errors_374
03749 };
03750
03751 static char* signature_375[] = { "Object", "String"};
03752 static char* errors_375[] = {NULL};
03753 static primitive_desc primitive_375 = {
03754 "primitiveWriteSnapshot:",
03755 fntype(&systemPrimitives::writeSnapshot),
03756 65537,
03757 signature_375,
03758 errors_375
03759 };
03760
03761 static int size_of_primitive_table = 376;
03762 static primitive_desc* primitive_table[] = {
03763 &primitive_0,
03764 &primitive_1,
03765 &primitive_2,
03766 &primitive_3,
03767 &primitive_4,
03768 &primitive_5,
03769 &primitive_6,
03770 &primitive_7,
03771 &primitive_8,
03772 &primitive_9,
03773 &primitive_10,
03774 &primitive_11,
03775 &primitive_12,
03776 &primitive_13,
03777 &primitive_14,
03778 &primitive_15,
03779 &primitive_16,
03780 &primitive_17,
03781 &primitive_18,
03782 &primitive_19,
03783 &primitive_20,
03784 &primitive_21,
03785 &primitive_22,
03786 &primitive_23,
03787 &primitive_24,
03788 &primitive_25,
03789 &primitive_26,
03790 &primitive_27,
03791 &primitive_28,
03792 &primitive_29,
03793 &primitive_30,
03794 &primitive_31,
03795 &primitive_32,
03796 &primitive_33,
03797 &primitive_34,
03798 &primitive_35,
03799 &primitive_36,
03800 &primitive_37,
03801 &primitive_38,
03802 &primitive_39,
03803 &primitive_40,
03804 &primitive_41,
03805 &primitive_42,
03806 &primitive_43,
03807 &primitive_44,
03808 &primitive_45,
03809 &primitive_46,
03810 &primitive_47,
03811 &primitive_48,
03812 &primitive_49,
03813 &primitive_50,
03814 &primitive_51,
03815 &primitive_52,
03816 &primitive_53,
03817 &primitive_54,
03818 &primitive_55,
03819 &primitive_56,
03820 &primitive_57,
03821 &primitive_58,
03822 &primitive_59,
03823 &primitive_60,
03824 &primitive_61,
03825 &primitive_62,
03826 &primitive_63,
03827 &primitive_64,
03828 &primitive_65,
03829 &primitive_66,
03830 &primitive_67,
03831 &primitive_68,
03832 &primitive_69,
03833 &primitive_70,
03834 &primitive_71,
03835 &primitive_72,
03836 &primitive_73,
03837 &primitive_74,
03838 &primitive_75,
03839 &primitive_76,
03840 &primitive_77,
03841 &primitive_78,
03842 &primitive_79,
03843 &primitive_80,
03844 &primitive_81,
03845 &primitive_82,
03846 &primitive_83,
03847 &primitive_84,
03848 &primitive_85,
03849 &primitive_86,
03850 &primitive_87,
03851 &primitive_88,
03852 &primitive_89,
03853 &primitive_90,
03854 &primitive_91,
03855 &primitive_92,
03856 &primitive_93,
03857 &primitive_94,
03858 &primitive_95,
03859 &primitive_96,
03860 &primitive_97,
03861 &primitive_98,
03862 &primitive_99,
03863 &primitive_100,
03864 &primitive_101,
03865 &primitive_102,
03866 &primitive_103,
03867 &primitive_104,
03868 &primitive_105,
03869 &primitive_106,
03870 &primitive_107,
03871 &primitive_108,
03872 &primitive_109,
03873 &primitive_110,
03874 &primitive_111,
03875 &primitive_112,
03876 &primitive_113,
03877 &primitive_114,
03878 &primitive_115,
03879 &primitive_116,
03880 &primitive_117,
03881 &primitive_118,
03882 &primitive_119,
03883 &primitive_120,
03884 &primitive_121,
03885 &primitive_122,
03886 &primitive_123,
03887 &primitive_124,
03888 &primitive_125,
03889 &primitive_126,
03890 &primitive_127,
03891 &primitive_128,
03892 &primitive_129,
03893 &primitive_130,
03894 &primitive_131,
03895 &primitive_132,
03896 &primitive_133,
03897 &primitive_134,
03898 &primitive_135,
03899 &primitive_136,
03900 &primitive_137,
03901 &primitive_138,
03902 &primitive_139,
03903 &primitive_140,
03904 &primitive_141,
03905 &primitive_142,
03906 &primitive_143,
03907 &primitive_144,
03908 &primitive_145,
03909 &primitive_146,
03910 &primitive_147,
03911 &primitive_148,
03912 &primitive_149,
03913 &primitive_150,
03914 &primitive_151,
03915 &primitive_152,
03916 &primitive_153,
03917 &primitive_154,
03918 &primitive_155,
03919 &primitive_156,
03920 &primitive_157,
03921 &primitive_158,
03922 &primitive_159,
03923 &primitive_160,
03924 &primitive_161,
03925 &primitive_162,
03926 &primitive_163,
03927 &primitive_164,
03928 &primitive_165,
03929 &primitive_166,
03930 &primitive_167,
03931 &primitive_168,
03932 &primitive_169,
03933 &primitive_170,
03934 &primitive_171,
03935 &primitive_172,
03936 &primitive_173,
03937 &primitive_174,
03938 &primitive_175,
03939 &primitive_176,
03940 &primitive_177,
03941 &primitive_178,
03942 &primitive_179,
03943 &primitive_180,
03944 &primitive_181,
03945 &primitive_182,
03946 &primitive_183,
03947 &primitive_184,
03948 &primitive_185,
03949 &primitive_186,
03950 &primitive_187,
03951 &primitive_188,
03952 &primitive_189,
03953 &primitive_190,
03954 &primitive_191,
03955 &primitive_192,
03956 &primitive_193,
03957 &primitive_194,
03958 &primitive_195,
03959 &primitive_196,
03960 &primitive_197,
03961 &primitive_198,
03962 &primitive_199,
03963 &primitive_200,
03964 &primitive_201,
03965 &primitive_202,
03966 &primitive_203,
03967 &primitive_204,
03968 &primitive_205,
03969 &primitive_206,
03970 &primitive_207,
03971 &primitive_208,
03972 &primitive_209,
03973 &primitive_210,
03974 &primitive_211,
03975 &primitive_212,
03976 &primitive_213,
03977 &primitive_214,
03978 &primitive_215,
03979 &primitive_216,
03980 &primitive_217,
03981 &primitive_218,
03982 &primitive_219,
03983 &primitive_220,
03984 &primitive_221,
03985 &primitive_222,
03986 &primitive_223,
03987 &primitive_224,
03988 &primitive_225,
03989 &primitive_226,
03990 &primitive_227,
03991 &primitive_228,
03992 &primitive_229,
03993 &primitive_230,
03994 &primitive_231,
03995 &primitive_232,
03996 &primitive_233,
03997 &primitive_234,
03998 &primitive_235,
03999 &primitive_236,
04000 &primitive_237,
04001 &primitive_238,
04002 &primitive_239,
04003 &primitive_240,
04004 &primitive_241,
04005 &primitive_242,
04006 &primitive_243,
04007 &primitive_244,
04008 &primitive_245,
04009 &primitive_246,
04010 &primitive_247,
04011 &primitive_248,
04012 &primitive_249,
04013 &primitive_250,
04014 &primitive_251,
04015 &primitive_252,
04016 &primitive_253,
04017 &primitive_254,
04018 &primitive_255,
04019 &primitive_256,
04020 &primitive_257,
04021 &primitive_258,
04022 &primitive_259,
04023 &primitive_260,
04024 &primitive_261,
04025 &primitive_262,
04026 &primitive_263,
04027 &primitive_264,
04028 &primitive_265,
04029 &primitive_266,
04030 &primitive_267,
04031 &primitive_268,
04032 &primitive_269,
04033 &primitive_270,
04034 &primitive_271,
04035 &primitive_272,
04036 &primitive_273,
04037 &primitive_274,
04038 &primitive_275,
04039 &primitive_276,
04040 &primitive_277,
04041 &primitive_278,
04042 &primitive_279,
04043 &primitive_280,
04044 &primitive_281,
04045 &primitive_282,
04046 &primitive_283,
04047 &primitive_284,
04048 &primitive_285,
04049 &primitive_286,
04050 &primitive_287,
04051 &primitive_288,
04052 &primitive_289,
04053 &primitive_290,
04054 &primitive_291,
04055 &primitive_292,
04056 &primitive_293,
04057 &primitive_294,
04058 &primitive_295,
04059 &primitive_296,
04060 &primitive_297,
04061 &primitive_298,
04062 &primitive_299,
04063 &primitive_300,
04064 &primitive_301,
04065 &primitive_302,
04066 &primitive_303,
04067 &primitive_304,
04068 &primitive_305,
04069 &primitive_306,
04070 &primitive_307,
04071 &primitive_308,
04072 &primitive_309,
04073 &primitive_310,
04074 &primitive_311,
04075 &primitive_312,
04076 &primitive_313,
04077 &primitive_314,
04078 &primitive_315,
04079 &primitive_316,
04080 &primitive_317,
04081 &primitive_318,
04082 &primitive_319,
04083 &primitive_320,
04084 &primitive_321,
04085 &primitive_322,
04086 &primitive_323,
04087 &primitive_324,
04088 &primitive_325,
04089 &primitive_326,
04090 &primitive_327,
04091 &primitive_328,
04092 &primitive_329,
04093 &primitive_330,
04094 &primitive_331,
04095 &primitive_332,
04096 &primitive_333,
04097 &primitive_334,
04098 &primitive_335,
04099 &primitive_336,
04100 &primitive_337,
04101 &primitive_338,
04102 &primitive_339,
04103 &primitive_340,
04104 &primitive_341,
04105 &primitive_342,
04106 &primitive_343,
04107 &primitive_344,
04108 &primitive_345,
04109 &primitive_346,
04110 &primitive_347,
04111 &primitive_348,
04112 &primitive_349,
04113 &primitive_350,
04114 &primitive_351,
04115 &primitive_352,
04116 &primitive_353,
04117 &primitive_354,
04118 &primitive_355,
04119 &primitive_356,
04120 &primitive_357,
04121 &primitive_358,
04122 &primitive_359,
04123 &primitive_360,
04124 &primitive_361,
04125 &primitive_362,
04126 &primitive_363,
04127 &primitive_364,
04128 &primitive_365,
04129 &primitive_366,
04130 &primitive_367,
04131 &primitive_368,
04132 &primitive_369,
04133 &primitive_370,
04134 &primitive_371,
04135 &primitive_372,
04136 &primitive_373,
04137 &primitive_374,
04138 &primitive_375
04139 };
