primitiveSerialPortRead(void) { // SerialPlugin>>#primitiveSerialPortRead char *array; sqInt arrayPtr; sqInt bytesRead; sqInt count; sqInt portNum; sqInt startIndex; sqInt _return_value; portNum = stackIntegerValue(3); success(isBytes(stackValue(2))); array = ((char *) (firstIndexableField(stackValue(2)))); startIndex = stackIntegerValue(1); count = stackIntegerValue(0); if (failed()) { return null; } success((startIndex >= 1) && (((startIndex + count) - 1) <= (byteSizeOf(((sqInt)(long)(array) - 4))))); arrayPtr = ((((sqInt)array)) + startIndex) - 1; bytesRead = serialPortReadInto( portNum, count, arrayPtr); _return_value = integerObjectOf(bytesRead); if (failed()) { return null; } popthenPush(5, _return_value); return null; }
primitiveSoundPlaySamples(void) { // SoundPlugin>>#primitiveSoundPlaySamples unsigned *buf; sqInt frameCount; sqInt framesPlayed; sqInt startIndex; sqInt _return_value; frameCount = stackIntegerValue(2); success(isWords(stackValue(1))); buf = ((unsigned *) (firstIndexableField(stackValue(1)))); startIndex = stackIntegerValue(0); if (failed()) { return null; } success((startIndex >= 1) && (((startIndex + frameCount) - 1) <= (slotSizeOf(((sqInt)(long)(buf) - BaseHeaderSize))))); if (!(failed())) { framesPlayed = snd_PlaySamplesFromAtLength(frameCount, (void *)buf, startIndex - 1); success(framesPlayed >= 0); } _return_value = positive32BitIntegerFor(framesPlayed); if (failed()) { return null; } popthenPush(4, _return_value); return null; }
primitiveSoundInsertSamples(void) { // SoundPlugin>>#primitiveSoundInsertSamples unsigned *buf; sqInt frameCount; sqInt framesPlayed; sqInt leadTime; sqInt _return_value; frameCount = stackIntegerValue(2); success(isWords(stackValue(1))); buf = ((unsigned *) (firstIndexableField(stackValue(1)))); leadTime = stackIntegerValue(0); if (failed()) { return null; } success(frameCount <= (slotSizeOf(((sqInt)(long)(buf) - BaseHeaderSize)))); if (!(failed())) { framesPlayed = snd_InsertSamplesFromLeadTime(frameCount, (void *)buf, leadTime); success(framesPlayed >= 0); } _return_value = positive32BitIntegerFor(framesPlayed); if (failed()) { return null; } popthenPush(4, _return_value); return null; }
primitiveCreateRenderer(void) { // B3DAcceleratorPlugin>>#primitiveCreateRenderer sqInt allowHardware; sqInt allowSoftware; sqInt h; sqInt result; sqInt w; sqInt x; sqInt y; if (!((methodArgumentCount()) == 6)) { return primitiveFail(); } h = stackIntegerValue(0); w = stackIntegerValue(1); y = stackIntegerValue(2); x = stackIntegerValue(3); allowHardware = booleanValueOf(stackValue(4)); allowSoftware = booleanValueOf(stackValue(5)); if (failed()) { return null; } result = b3dxCreateRenderer(allowSoftware, allowHardware, x, y, w, h); if (result < 0) { return primitiveFail(); } pop(7); return pushInteger(result); }
primitiveSerialPortWrite(void) { char *array; char * arrayPtr; sqInt bytesWritten; sqInt count; sqInt portNum; sqInt startIndex; sqInt _return_value; bytesWritten = 0; portNum = stackIntegerValue(3); success(isBytes(stackValue(2))); array = ((char *) (firstIndexableField(stackValue(2)))); startIndex = stackIntegerValue(1); count = stackIntegerValue(0); if (failed()) { return null; } success((startIndex >= 1) && (((startIndex + count) - 1) <= (byteSizeOf(((sqInt)(sqIntptr_t)(array) - BaseHeaderSize))))); if (!(failed())) { arrayPtr = (array + startIndex) - 1; bytesWritten = serialPortWriteFrom(portNum, count, arrayPtr); } if (failed()) { return null; } _return_value = integerObjectOf(bytesWritten); popthenPush(5, _return_value); return null; }
primitiveAtPut(void) { float *floatPtr; double floatValue; sqInt index; sqInt rcvr; sqInt value; value = stackValue(0); if (isIntegerObject(value)) { floatValue = ((double) (integerValueOf(value)) ); } else { floatValue = floatValueOf(value); } index = stackIntegerValue(1); rcvr = stackValue(2); if (!((!(failed())) && ((isWords(rcvr)) && ((index > 0) && (index <= (slotSizeOf(rcvr))))))) { return primitiveFail(); } floatPtr = firstIndexableField(rcvr); floatPtr[index - 1] = (((float) floatValue)); popthenPush(3, value); return 0; }
primitiveFileCopyNamedTo(void) { // FileCopyPlugin>>#primitiveFileCopyNamedTo char *dstName; sqInt dstSz; sqInt ok; char *srcName; sqInt srcSz; success(isBytes(stackValue(1))); srcName = ((char *) (firstIndexableField(stackValue(1)))); success(isBytes(stackValue(0))); dstName = ((char *) (firstIndexableField(stackValue(0)))); if (failed()) { return null; } srcSz = slotSizeOf(((sqInt)(long)(srcName) - 4)); dstSz = slotSizeOf(((sqInt)(long)(dstName) - 4)); ok = sqCopyFilesizetosize(srcName, srcSz, dstName, dstSz); if (!ok) { primitiveFail(); } if (failed()) { return null; } pop(2); return null; }
primitiveFlushICacheFromTo(void) { void *cpu; sqInt cpuAlien; usqIntptr_t endAddress; usqIntptr_t startAddress; startAddress = (BytesPerOop == 4 ? positive32BitValueOf(stackValue(1)) : positive64BitValueOf(stackValue(1))); endAddress = (BytesPerOop == 4 ? positive32BitValueOf(stackValue(0)) : positive64BitValueOf(stackValue(0))); cpuAlien = stackValue(2); if (failed()) { return null; } if (((cpu = ((longAt(cpuAlien + BaseHeaderSize)) > 0 ? (cpuAlien + BaseHeaderSize) + BytesPerOop : longAt((cpuAlien + BaseHeaderSize) + BytesPerOop)))) == 0) { primitiveFailFor(PrimErrBadReceiver); return null; } flushICacheFromTo(cpu, startAddress, endAddress); if (failed()) { return null; } pop(2); return null; }
primitiveGetStringKeyedBy(void) { char *aKey; char aString[1025]; sqInt i; sqInt keyLength; sqInt oop; char *ptr; sqInt size; success(isBytes(stackValue(0))); aKey = ((char *) (firstIndexableField(stackValue(0)))); if (failed()) { return null; } keyLength = byteSizeOf(((sqInt)(sqIntptr_t)(aKey) - BaseHeaderSize)); size = sqInternetConfigurationGetStringKeyedBykeySizeinto(aKey, keyLength, aString); oop = instantiateClassindexableSize(classString(), size); ptr = firstIndexableField(oop); for (i = 0; i < size; i += 1) { ptr[i] = (aString[i]); } if (failed()) { return null; } popthenPush(2, oop); return null; }
primitiveEqual(void) { sqInt arg; float *argPtr; sqInt i; sqInt length; sqInt rcvr; float *rcvrPtr; arg = stackValue(0); rcvr = stackValue(1); if (!((isWords(arg)) && (isWords(rcvr)))) { return primitiveFail(); } pop(2); if (!(((length = stSizeOf(arg))) == (stSizeOf(rcvr)))) { return pushBool(0); } rcvrPtr = ((float *) (firstIndexableField(rcvr))); argPtr = ((float *) (firstIndexableField(arg))); for (i = 0; i < length; i += 1) { if (!((rcvrPtr[i]) == (argPtr[i]))) { return pushBool(0); } } return pushBool(1); }
primitiveSetFog(void) { // B3DAcceleratorPlugin>>#primitiveSetFog double density; sqInt fogType; sqInt handle; sqInt result; sqInt rgba; double start; double stop; if (!((methodArgumentCount()) == 6)) { return primitiveFail(); } rgba = positive32BitValueOf(stackValue(0)); stop = floatValueOf(stackValue(1)); start = floatValueOf(stackValue(2)); density = floatValueOf(stackValue(3)); fogType = stackIntegerValue(4); handle = stackIntegerValue(5); if (failed()) { return null; } result = b3dxSetFog(handle, fogType, density, start, stop, rgba); if (!result) { return primitiveFail(); } return pop(6); }
primitiveFileTruncate(void) { // FilePlugin>>#primitiveFileTruncate SQFile *file; sqInt objectPointer; sqInt sz; squeakFileOffsetType truncatePosition; if (!(isIntegerObject(stackValue(0)))) { sz = sizeof(squeakFileOffsetType); if ((byteSizeOf(stackValue(0))) > sz) { return primitiveFail(); } } truncatePosition = positive64BitValueOf(stackValue(0)); /* begin fileValueOf: */ objectPointer = stackValue(1); if (!((isBytes(objectPointer)) && ((byteSizeOf(objectPointer)) == (sizeof(SQFile))))) { primitiveFail(); file = null; goto l1; } file = firstIndexableField(objectPointer); l1: /* end fileValueOf: */; if (!(failed())) { sqFileTruncate(file, truncatePosition); } if (!(failed())) { pop(2); } }
primitiveDotProduct(void) { sqInt arg; float *argPtr; sqInt i; sqInt length; sqInt rcvr; float *rcvrPtr; double result; arg = stackValue(0); rcvr = stackValue(1); if (!((isWords(arg)) && ((isWords(rcvr)) && (((length = stSizeOf(arg))) == (stSizeOf(rcvr)))))) { return primitiveFail(); } rcvrPtr = ((float *) (firstIndexableField(rcvr))); argPtr = ((float *) (firstIndexableField(arg))); result = 0.0; for (i = 0; i < length; i += 1) { result += (((double) (rcvrPtr[i]))) * (((double) (argPtr[i]))); } pop(2); pushFloat(result); return 0; }
primitiveDivFloatArray(void) { sqInt arg; float *argPtr; sqInt i; sqInt length; sqInt rcvr; float *rcvrPtr; arg = stackValue(0); rcvr = stackValue(1); if (!((isWords(arg)) && ((isWords(rcvr)) && (((length = stSizeOf(arg))) == (stSizeOf(rcvr)))))) { return primitiveFail(); } rcvrPtr = ((float *) (firstIndexableField(rcvr))); /* Check if any of the argument's values is zero */ argPtr = ((float *) (firstIndexableField(arg))); for (i = 0; i < length; i += 1) { if ((intAtPointer(((char*) (argPtr + i)))) == 0) { return primitiveFail(); } } for (i = 0; i < length; i += 1) { rcvrPtr[i] = ((((double) (rcvrPtr[i]))) / (((double) (argPtr[i])))); } pop(1); return 0; }
primitiveGetMacintoshFileTypeAndCreatorFrom(void) { char *aFileName; char creator[8]; sqInt i; sqInt keyLength; sqInt oop; char *ptr; success(isBytes(stackValue(0))); aFileName = ((char *) (firstIndexableField(stackValue(0)))); if (failed()) { return null; } keyLength = byteSizeOf(((sqInt)(sqIntptr_t)(aFileName) - BaseHeaderSize)); sqInternetGetMacintoshFileTypeAndCreatorFromkeySizeinto(aFileName, keyLength, creator); oop = instantiateClassindexableSize(classString(), 8); ptr = firstIndexableField(oop); for (i = 0; i <= 7; i += 1) { ptr[i] = (creator[i]); } if (failed()) { return null; } popthenPush(2, oop); return null; }
primitiveDisassembleAtInMemory(void) { usqIntptr_t address; void *cpu; sqInt cpuAlien; sqInt instrLenOrErr; sqInt log; sqInt logLen; sqInt logObj; sqInt logObjData; char *memory; sqInt resultObj; logLen = 0; address = (BytesPerOop == 4 ? positive32BitValueOf(stackValue(1)) : positive64BitValueOf(stackValue(1))); success(isWordsOrBytes(stackValue(0))); memory = ((char *) (firstIndexableField(stackValue(0)))); cpuAlien = stackValue(2); if (failed()) { return null; } if (((cpu = ((longAt(cpuAlien + BaseHeaderSize)) > 0 ? (cpuAlien + BaseHeaderSize) + BytesPerOop : longAt((cpuAlien + BaseHeaderSize) + BytesPerOop)))) == 0) { primitiveFailFor(PrimErrBadReceiver); return null; } instrLenOrErr = disassembleForAtInSize(cpu, address, memory, byteSizeOf(((sqInt)(sqIntptr_t)(memory) - BaseHeaderSize))); if (instrLenOrErr < 0) { primitiveFailFor(PrimErrInappropriate); return null; } log = getlog((&logLen)); resultObj = instantiateClassindexableSize(classArray(), 2); if (resultObj == 0) { primitiveFailFor(PrimErrNoMemory); return null; } pushRemappableOop(resultObj); logObj = instantiateClassindexableSize(classString(), logLen); if (failed()) { popRemappableOop(); primitiveFailFor(PrimErrNoMemory); return null; } logObjData = arrayValueOf(logObj); memcpy(logObjData, log, logLen); resultObj = popRemappableOop(); storePointerofObjectwithValue(0, resultObj, integerObjectOf(instrLenOrErr)); storePointerofObjectwithValue(1, resultObj, logObj); if (failed()) { return null; } popthenPush(3, resultObj); return null; }
primitiveAsyncFileWriteStart(void) { // AsynchFilePlugin>>#primitiveAsyncFileWriteStart sqInt buffer; sqInt bufferPtr; sqInt bufferSize; sqInt count; AsyncFile *f; sqInt fHandle; sqInt fPosition; sqInt num; sqInt start; sqInt startIndex; fHandle = stackValue(4); fPosition = stackIntegerValue(3); buffer = stackValue(2); start = stackIntegerValue(1); num = stackIntegerValue(0); if (failed()) { return null; } f = asyncFileValueOf(fHandle); if (failed()) { return null; } count = num; startIndex = start; /* in bytes or words */ bufferSize = slotSizeOf(buffer); if (isWords(buffer)) { /* covert word counts to byte counts */ /* covert word counts to byte counts */ count = count * 4; startIndex = ((startIndex - 1) * 4) + 1; bufferSize = bufferSize * 4; } success((startIndex >= 1) && (((startIndex + count) - 1) <= bufferSize)); /* adjust for zero-origin indexing */ bufferPtr = ((((int) (firstIndexableField(buffer)))) + startIndex) - 1; if (!(failed())) { asyncFileWriteStart(f, fPosition, bufferPtr, count); } if (failed()) { return null; } pop(5); return null; }
Oop* __fastcall Interpreter::primitivePerform(CompiledMethod& , unsigned argCount) { SymbolOTE* performSelector = m_oopMessageSelector; // Save in case we need to restore SymbolOTE* selectorToPerform = reinterpret_cast<SymbolOTE*>(stackValue(argCount-1)); if (ObjectMemoryIsIntegerObject(selectorToPerform)) return primitiveFailure(1); m_oopMessageSelector = selectorToPerform; Oop newReceiver = stackValue(argCount); // lookupMethodInClass returns the Oop of the new CompiledMethod // if the selector is found, or Pointers.DoesNotUnderstand if the class // does not understand the selector. We succeed if either the argument // count of the returned method matches that passed to this primitive, // or if the selector is not understood, because by this time the // detection of the 'does not understand' will have triggered // the create of a Message object (see createActualMessage) into // which all the arguments will have been moved, and which then replaces // those arguments on the Smalltalk context stack. i.e. the primitive // will succeed if the message is not understood, but will result in // the execution of doesNotUnderstand: rather than the selector we've // been asked to perform. This works because // after a doesNotUnderstand detection, the stack has a Message at stack // top, the selector is still there, and argCount is now 1. Consequently // the Message gets shuffled over the selector, and doesNotUnderstand is // sent MethodOTE* methodPointer = findNewMethodInClass(ObjectMemory::fetchClassOf(newReceiver), (argCount-1)); CompiledMethod* method = methodPointer->m_location; if (method->m_header.argumentCount == (argCount-1) || m_oopMessageSelector == Pointers.DoesNotUnderstandSelector) { // Shuffle arguments down over the selector (use argumentCount of // method found which may not equal argCount) const unsigned methodArgCount = method->m_header.argumentCount; // #pragma message("primitivePerform: Instead of shuffling args down 1, why not just deduct 1 from calling frames suspended SP after exec?") Oop* const sp = m_registers.m_stackPointer - methodArgCount; // We don't need to count down the overwritten oop anymore, since we don't ref. count stack ops // Not worth overhead of calling memmove here since argumentCount // normally small for (unsigned i=0;i<methodArgCount;i++) sp[i] = sp[i+1]; popStack(); executeNewMethod(methodPointer, methodArgCount); return primitiveSuccess(0); } else { // The argument count did not match, so drop out into the Smalltalk // having restored the selector ASSERT(m_oopMessageSelector!=Pointers.DoesNotUnderstandSelector); m_oopMessageSelector = performSelector; return primitiveFailure(0); } }
primitiveAsyncFileReadResult(void) { // AsynchFilePlugin>>#primitiveAsyncFileReadResult sqInt buffer; sqInt bufferPtr; sqInt bufferSize; sqInt count; AsyncFile *f; sqInt fhandle; sqInt num; sqInt r; sqInt start; sqInt startIndex; sqInt _return_value; fhandle = stackValue(3); buffer = stackValue(2); start = stackIntegerValue(1); num = stackIntegerValue(0); if (failed()) { return null; } f = asyncFileValueOf(fhandle); count = num; startIndex = start; /* in bytes or words */ bufferSize = slotSizeOf(buffer); if (isWords(buffer)) { /* covert word counts to byte counts */ /* covert word counts to byte counts */ count = count * 4; startIndex = ((startIndex - 1) * 4) + 1; bufferSize = bufferSize * 4; } success((startIndex >= 1) && (((startIndex + count) - 1) <= bufferSize)); /* adjust for zero-origin indexing */ bufferPtr = ((((int) (firstIndexableField(buffer)))) + startIndex) - 1; if (!(failed())) { r = asyncFileReadResult(f, bufferPtr, count); } _return_value = integerObjectOf(r); if (failed()) { return null; } popthenPush(5, _return_value); return null; }
// Locate the next occurrence of the given character in the receiver between the specified indices. BOOL __fastcall Interpreter::primitiveStringNextIndexOfFromTo() { Oop integerPointer = stackTop(); if (!ObjectMemoryIsIntegerObject(integerPointer)) return primitiveFailure(0); // to not an integer const SMALLINTEGER to = ObjectMemoryIntegerValueOf(integerPointer); integerPointer = stackValue(1); if (!ObjectMemoryIsIntegerObject(integerPointer)) return primitiveFailure(1); // from not an integer SMALLINTEGER from = ObjectMemoryIntegerValueOf(integerPointer); Oop valuePointer = stackValue(2); StringOTE* receiverPointer = reinterpret_cast<StringOTE*>(stackValue(3)); Oop answer = ZeroPointer; if ((ObjectMemory::fetchClassOf(valuePointer) == Pointers.ClassCharacter) && to >= from) { ASSERT(!receiverPointer->isPointers()); // Search a byte object const SMALLINTEGER length = receiverPointer->bytesSize(); // We can only be in here if to>=from, so if to>=1, then => from >= 1 // furthermore if to <= length then => from <= length if (from < 1 || to > length) return primitiveFailure(2); // Search is in bounds, lets do it CharOTE* oteChar = reinterpret_cast<CharOTE*>(valuePointer); Character* charObj = oteChar->m_location; const char charValue = static_cast<char>(ObjectMemoryIntegerValueOf(charObj->m_asciiValue)); String* chars = receiverPointer->m_location; from--; while (from < to) { if (chars->m_characters[from++] == charValue) { answer = ObjectMemoryIntegerObjectOf(from); break; } } } stackValue(3) = answer; pop(3); return primitiveSuccess(); }
primitiveFileRead(void) { // FilePlugin>>#primitiveFileRead sqInt array; sqInt bytesRead; size_t count; size_t elementSize; SQFile *file; sqInt objectPointer; sqInt retryCount; size_t startIndex; retryCount = 0; count = positive32BitValueOf(stackValue(0)); startIndex = positive32BitValueOf(stackValue(1)); while (1) { array = stackValue(2); /* begin fileValueOf: */ objectPointer = stackValue(3); if (!((isBytes(objectPointer)) && ((byteSizeOf(objectPointer)) == (sizeof(SQFile))))) { primitiveFail(); file = null; goto l1; } file = firstIndexableField(objectPointer); l1: /* end fileValueOf: */; if ((failed()) || (!(isWordsOrBytes(array)))) { return primitiveFailFor(PrimErrBadArgument); } elementSize = (isWords(array) ? 4 : 1); if (!((startIndex >= 1) && (((startIndex + count) - 1) <= (slotSizeOf(array))))) { return primitiveFailFor(PrimErrBadIndex); } bytesRead = sqFileReadIntoAt(file, count * elementSize, ((char *) (firstIndexableField(array))), (startIndex - 1) * elementSize); if (!(((primitiveFailureCode()) == PrimErrObjectMayMove) && (((retryCount += 1)) <= 2))) break; tenuringIncrementalGC(); primitiveFailFor(PrimNoErr); } if (!(failed())) { popthenPush(5, integerObjectOf(bytesRead / elementSize)); } }
primitiveSetIntProperty(void) { sqInt handle; sqInt propID; sqInt result; sqInt value; if (!((methodArgumentCount()) == 3)) { return primitiveFail(); } value = signed32BitValueOf(stackValue(0)); propID = stackIntegerValue(1); handle = stackIntegerValue(2); if (failed()) { return null; } result = sqSetIntPropertySSL(handle, propID, value); if (!result) { return primitiveFail(); } if (failed()) { return null; } pop(methodArgumentCount()); return 0; }
primitiveOSFileHandle(void) { sqInt fileNo; sqInt sqFileOop; sqFileOop = stackValue(0); if (!((((isBytes(sqFileOop)) && ((byteSizeOf(sqFileOop)) == (sizeof(SQFile)))) && ((getThisSessionID()) == (sessionIdentifierFromSqFile(arrayValueOf(sqFileOop))))) && (isNonNullSQFile(sqFileOop)))) { return primitiveFail(); } /* begin fileDescriptorFrom: */ if (!((((isBytes(sqFileOop)) && ((byteSizeOf(sqFileOop)) == (sizeof(SQFile)))) && ((getThisSessionID()) == (sessionIdentifierFromSqFile(arrayValueOf(sqFileOop))))) && (isNonNullSQFile(sqFileOop)))) { fileNo = -1; goto l1; } fileNo = fileno(fileHandleFrom(sqFileOop)); l1: /* end fileDescriptorFrom: */; pop(2); pushInteger(fileNo); return 0; }
primitiveAioSuspend(void) { sqInt exceptionWatch; sqInt fd; sqInt flags; sqInt readWatch; sqInt writeWatch; if ((nilObject()) == (stackValue(3))) { return primitiveFail(); } fd = stackIntegerValue(3); if (fd < 0) { return primitiveFail(); } exceptionWatch = stackObjectValue(2); readWatch = stackObjectValue(1); writeWatch = stackObjectValue(0); flags = 0; if (exceptionWatch == (trueObject())) { flags = flags | (AIO_X); } if (readWatch == (trueObject())) { flags = flags | (AIO_R); } if (writeWatch == (trueObject())) { flags = flags | (AIO_W); } aioSuspend(fd, flags); pop(5); pushInteger(flags); return 0; }
primitiveAioEnable(void) { static int eventSemaphoreIndices[FD_SETSIZE]; sqInt externalObject; sqInt fd; sqInt flags; sqInt semaIndex; if ((nilObject()) == (stackValue(2))) { return primitiveFail(); } fd = stackIntegerValue(2); if (fd < 0) { return primitiveFail(); } semaIndex = stackIntegerValue(1); eventSemaphoreIndices[semaIndex] = semaIndex; externalObject = stackObjectValue(0); if (externalObject == (trueObject())) { flags = AIO_EXT; } else { flags = 0; } aioEnable(fd, &(eventSemaphoreIndices[semaIndex]), flags); pop(4); pushInteger(semaIndex); return 0; }
primitiveFileDelete(void) { // FilePlugin>>#primitiveFileDelete char *nameIndex; sqInt namePointer; sqInt nameSize; sqInt okToDelete; namePointer = stackValue(0); if (!(isBytes(namePointer))) { return primitiveFail(); } nameIndex = firstIndexableField(namePointer); /* If the security plugin can be loaded, use it to check for permission. If not, assume it's ok */ nameSize = byteSizeOf(namePointer); if (sCDFfn != 0) { okToDelete = ((sqInt (*)(char *, sqInt))sCDFfn)(nameIndex, nameSize); if (!okToDelete) { return primitiveFail(); } } sqFileDeleteNameSize(nameIndex, nameSize); if (!(failed())) { pop(1); } }
primitiveFileAtEnd(void) { // FilePlugin>>#primitiveFileAtEnd sqInt atEnd; SQFile *file; sqInt objectPointer; /* begin fileValueOf: */ objectPointer = stackValue(0); if (!((isBytes(objectPointer)) && ((byteSizeOf(objectPointer)) == (sizeof(SQFile))))) { primitiveFail(); file = null; goto l1; } file = firstIndexableField(objectPointer); l1: /* end fileValueOf: */; if (!(failed())) { atEnd = sqFileAtEnd(file); } if (!(failed())) { pop(2); pushBool(atEnd); } }
primitiveDirectoryDelete(void) { // FilePlugin>>#primitiveDirectoryDelete sqInt dirName; char *dirNameIndex; sqInt dirNameSize; sqInt okToDelete; dirName = stackValue(0); if (!(isBytes(dirName))) { return primitiveFail(); } dirNameIndex = firstIndexableField(dirName); /* If the security plugin can be loaded, use it to check for permission. If not, assume it's ok */ dirNameSize = byteSizeOf(dirName); if (sCDPfn != 0) { okToDelete = ((sqInt (*)(char *, sqInt))sCDPfn)(dirNameIndex, dirNameSize); if (!okToDelete) { return primitiveFail(); } } if (!(dir_Delete(dirNameIndex, dirNameSize))) { return primitiveFail(); } pop(1); }
primitiveNormalize(void) { sqInt i; double len; sqInt length; sqInt rcvr; float *rcvrPtr; rcvr = stackValue(0); if (!(isWords(rcvr))) { primitiveFailFor(PrimErrBadReceiver); } length = stSizeOf(rcvr); rcvrPtr = ((float *) (firstIndexableField(rcvr))); len = 0.0; for (i = 0; i < length; i += 1) { len += (((double) (rcvrPtr[i]))) * (((double) (rcvrPtr[i]))); } if (!(len > 0.0)) { primitiveFailFor(PrimErrBadReceiver); } len = sqrt(len); for (i = 0; i < length; i += 1) { rcvrPtr[i] = ((((double) (rcvrPtr[i]))) / len); } return 0; }
primitiveResetCPU(void) { void *cpu; sqInt cpuAlien; sqInt maybeErr; cpuAlien = stackValue(0); if (failed()) { return null; } if (((cpu = ((longAt(cpuAlien + BaseHeaderSize)) > 0 ? (cpuAlien + BaseHeaderSize) + BytesPerOop : longAt((cpuAlien + BaseHeaderSize) + BytesPerOop)))) == 0) { primitiveFailFor(PrimErrBadReceiver); return null; } maybeErr = resetCPU(cpu); if (maybeErr != 0) { primitiveFailFor(PrimErrInappropriate); return null; } if (failed()) { return null; } popthenPush(1, cpuAlien); return null; }