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;
}
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;
}
primitiveSetStringProperty(void)
{
sqInt handle;
sqInt propID;
sqInt result;
sqInt srcLen;
sqInt srcOop;
char *srcPtr;
if (!((methodArgumentCount()) == 3)) {
return primitiveFail();
}
srcOop = stackObjectValue(0);
propID = stackIntegerValue(1);
handle = stackIntegerValue(2);
if (failed()) {
return null;
}
if (!(isBytes(srcOop))) {
return primitiveFail();
}
srcPtr = firstIndexableField(srcOop);
srcLen = byteSizeOf(srcOop);
result = sqSetStringPropertySSL(handle, propID, srcPtr, srcLen);
if (!result) {
return primitiveFail();
}
if (failed()) {
return null;
}
pop(methodArgumentCount());
return 0;
}
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);
}
}
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;
}
/*
primitivePluginRequestUrlStream: url with: semaIndex
Request a URL from the browser. Signal semaIndex
when the result of the request can be queried.
Returns a handle used in subsequent calls to plugin
stream functions.
Note: A request id is the index into requests[].
*/
int display_primitivePluginRequestURLStream()
{
sqStreamRequest *req;
int id, url, length, semaIndex;
if (!inBrowser) return primitiveFail();
DPRINT("VM: primitivePluginRequestURLStream()\n");
for (id=0; id<MAX_REQUESTS; id++) {
if (!requests[id]) break;
}
if (id >= MAX_REQUESTS) return primitiveFail();
semaIndex= stackIntegerValue(0);
url= stackObjectValue(1);
if (failed()) return 0;
if (!isBytes(url)) return primitiveFail();
req= calloc(1, sizeof(sqStreamRequest));
if (!req) return primitiveFail();
req->localName= NULL;
req->semaIndex= semaIndex;
req->state= -1;
requests[id]= req;
length= byteSizeOf(url);
browserGetURLRequest(id, firstIndexableField(url), length, NULL, 0);
pop(3);
push(positive32BitIntegerFor(id));
DPRINT("VM: request id: %i\n", id);
return 1;
}
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);
}
}
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;
}
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);
}
}
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;
}
primitiveDLSym(void)
{
void *addr;
sqInt i;
char *name;
sqInt nameObj;
char *namePtr;
sqInt sz;
nameObj = stackValue(0);
if (!(isBytes(nameObj))) {
return primitiveFailFor(PrimErrBadArgument);
}
sz = byteSizeOf(nameObj);
name = malloc(sz + 1);
namePtr = firstIndexableField(nameObj);
for (i = 0; i < sz; i += 1) {
name[i] = (namePtr[i]);
}
name[sz] = 0;
addr = dlsym(RTLD_SELF,name);
free(name);
return methodReturnValue((addr == 0
? nilObject()
: (/* begin positiveMachineIntegerFor: */
(BytesPerWord == 8
? positive64BitIntegerFor(((usqIntptr_t)addr))
: positive32BitIntegerFor(((usqIntptr_t)addr))))));
}
/* AioPlugin>>#isSQSocketObject: */
static sqInt
isSQSocketObject(sqInt objectPointer)
{
return ((isBytes(objectPointer))
&& ((byteSizeOf(objectPointer)) == (sizeof(SQSocket))))
&& (!(isNullSQSocket(objectPointer)));
}
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);
}
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;
}
/* AioPlugin>>#isSQFileObject: */
static sqInt
isSQFileObject(sqInt objectPointer)
{
return (((isBytes(objectPointer))
&& ((byteSizeOf(objectPointer)) == (sizeof(SQFile))))
&& ((getThisSessionID()) == (sessionIdentifierFromSqFile(arrayValueOf(objectPointer)))))
&& (isNonNullSQFile(objectPointer));
}
primitiveDirectoryGetMacTypeAndCreator(void)
{
// FilePlugin>>#primitiveDirectoryGetMacTypeAndCreator
sqInt creatorString;
char *creatorStringIndex;
sqInt fileName;
char *fileNameIndex;
sqInt fileNameSize;
sqInt okToGet;
sqInt typeString;
char *typeStringIndex;
creatorString = stackValue(0);
typeString = stackValue(1);
fileName = stackValue(2);
if (!((isBytes(creatorString))
&& ((byteSizeOf(creatorString)) == 4))) {
return primitiveFail();
}
if (!((isBytes(typeString))
&& ((byteSizeOf(typeString)) == 4))) {
return primitiveFail();
}
if (!(isBytes(fileName))) {
return primitiveFail();
}
creatorStringIndex = firstIndexableField(creatorString);
typeStringIndex = firstIndexableField(typeString);
fileNameIndex = firstIndexableField(fileName);
/* If the security plugin can be loaded, use it to check for permission.
If not, assume it's ok */
fileNameSize = byteSizeOf(fileName);
if (sCGFTfn != 0) {
okToGet = ((sqInt (*)(char *, sqInt))sCGFTfn)(fileNameIndex, fileNameSize);
if (!okToGet) {
return primitiveFail();
}
}
if (!(dir_GetMacFileTypeAndCreator(fileNameIndex, fileNameSize, typeStringIndex, creatorStringIndex))) {
return primitiveFail();
}
pop(3);
}
/*
primitivePluginPostURL: url target: target data: data semaIndex: semaIndex
Post data to a URL into the given target.
*/
int display_primitivePluginPostURL()
{
sqStreamRequest *req;
int url, urlLength;
int target, targetLength;
int data, dataLength;
int id, semaIndex;
if (!browserWindow) return primitiveFail();
for (id=0; id<MAX_REQUESTS; id++) {
if (!requests[id]) break;
}
if (id >= MAX_REQUESTS) return primitiveFail();
semaIndex= stackIntegerValue(0);
data= stackObjectValue(1);
target= stackObjectValue(2);
url= stackObjectValue(3);
if (failed()) return 0;
if (target == nilObject()) target= 0;
if (!isBytes(url) || !isBytes(data) || !(!target || isBytes(target))) return primitiveFail();
urlLength= byteSizeOf(url);
targetLength= target ? byteSizeOf(target) : 0;
dataLength= byteSizeOf(data);
req= calloc(1, sizeof(sqStreamRequest));
if(!req) return primitiveFail();
req->localName= NULL;
req->semaIndex= semaIndex;
req->state= -1;
requests[id]= req;
browserPostURLRequest(id, firstIndexableField(url), urlLength,
target ? firstIndexableField(target) : NULL, targetLength,
firstIndexableField(data), dataLength);
pop(4);
push(positive32BitIntegerFor(id));
return 1;
}
primitiveEncrypt(void)
{
sqInt dstLen;
sqInt dstOop;
char *dstPtr;
sqInt handle;
sqInt result;
sqInt srcLen;
sqInt srcOop;
char *srcPtr;
sqInt start;
if (!((methodArgumentCount()) == 5)) {
return primitiveFail();
}
dstOop = stackObjectValue(0);
srcLen = stackIntegerValue(1);
start = stackIntegerValue(2);
srcOop = stackObjectValue(3);
handle = stackIntegerValue(4);
if (failed()) {
return null;
}
if (!(((start > 0)
&& (srcLen >= 0))
&& ((isBytes(srcOop))
&& ((isBytes(dstOop))
&& ((byteSizeOf(srcOop)) >= ((start + srcLen) - 1)))))) {
return primitiveFail();
}
srcPtr = firstIndexableField(srcOop);
dstPtr = firstIndexableField(dstOop);
srcPtr = (srcPtr + start) - 1;
dstLen = byteSizeOf(dstOop);
result = sqEncryptSSL(handle, srcPtr, srcLen, dstPtr, dstLen);
if (failed()) {
return null;
}
pop((methodArgumentCount()) + 1);
pushInteger(result);
return 0;
}
/* AioPlugin>>#fileDescriptorFrom: */
static sqInt
fileDescriptorFrom(sqInt aSQFileByteArray)
{
if (!((((isBytes(aSQFileByteArray))
&& ((byteSizeOf(aSQFileByteArray)) == (sizeof(SQFile))))
&& ((getThisSessionID()) == (sessionIdentifierFromSqFile(arrayValueOf(aSQFileByteArray)))))
&& (isNonNullSQFile(aSQFileByteArray)))) {
return -1;
}
return fileno(fileHandleFrom(aSQFileByteArray));
}
SQFile *
fileValueOf(sqInt objectPointer)
{
// FilePlugin>>#fileValueOf:
if (!((isBytes(objectPointer))
&& ((byteSizeOf(objectPointer)) == (sizeof(SQFile))))) {
primitiveFail();
return null;
}
return firstIndexableField(objectPointer);
}
primitiveGSMDecode(void)
{
sqInt dst;
sqInt dstDelta;
sqInt dstIndex;
sqInt dstSize;
sqInt frameCount;
sqInt result;
sqInt src;
sqInt srcDelta;
sqInt srcIndex;
sqInt srcSize;
sqInt state;
dstDelta = 0;
srcDelta = 0;
dstIndex = stackIntegerValue(0);
dst = stackValue(1);
srcIndex = stackIntegerValue(2);
src = stackValue(3);
frameCount = stackIntegerValue(4);
state = stackValue(5);
success(isWords(dst));
success(isBytes(src));
success(isBytes(state));
if (failed()) {
return null;
}
srcSize = slotSizeOf(src);
dstSize = (slotSizeOf(dst)) * 2;
gsmDecode(state + BaseHeaderSize, frameCount, src, srcIndex, srcSize, dst, dstIndex, dstSize, &srcDelta, &dstDelta);
if (failed()) {
return null;
}
result = makePointwithxValueyValue(srcDelta, dstDelta);
if (failed()) {
return null;
}
popthenPush(6, result);
return 0;
}
static AsyncFile *
asyncFileValueOf(sqInt oop)
{
// AsynchFilePlugin>>#asyncFileValueOf:
success((!(isIntegerObject(oop)))
&& ((isBytes(oop))
&& ((slotSizeOf(oop)) == (sizeof(AsyncFile)))));
if (failed()) {
return null;
}
return (AsyncFile *) (oop + 4);
}
primitiveSerialPortWriteByName(void)
{
char *array;
char * arrayPtr;
sqInt bytesWritten;
sqInt count;
char *port;
char *portName;
sqInt portNameSize;
sqInt startIndex;
sqInt _return_value;
bytesWritten = 0;
success(isBytes(stackValue(3)));
portName = ((char *) (firstIndexableField(stackValue(3))));
success(isBytes(stackValue(2)));
array = ((char *) (firstIndexableField(stackValue(2))));
startIndex = stackIntegerValue(1);
count = stackIntegerValue(0);
if (failed()) {
return null;
}
portNameSize = slotSizeOf(((sqInt)((portName) - BaseHeaderSize)));
port = calloc(portNameSize+1, sizeof(char));
memcpy(port, portName, portNameSize);
success((startIndex >= 1)
&& (((startIndex + count) - 1) <= (byteSizeOf(((sqInt)(sqIntptr_t)(array) - BaseHeaderSize)))));
if (!(failed())) {
arrayPtr = (array + startIndex) - 1;
bytesWritten = serialPortWriteFromByName(port, count, arrayPtr);
}
free(port);
if (failed()) {
return null;
}
_return_value = integerObjectOf(bytesWritten);
popthenPush(5, _return_value);
return null;
}
primitiveSerialPortReadByName(void)
{
// SerialPlugin>>#primitiveSerialPortReadByName
char *array;
sqInt arrayPtr;
sqInt bytesRead;
sqInt count;
char *port;
char *portName;
sqInt portNameSize;
sqInt startIndex;
sqInt _return_value;
success(isBytes(stackValue(3)));
portName = ((char *) (firstIndexableField(stackValue(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)))));
portNameSize = slotSizeOf(((int) portName) - 4);
port = calloc(portNameSize+1, sizeof(char));
memcpy(port, portName, portNameSize);
arrayPtr = ((((sqInt)array)) + startIndex) - 1;
bytesRead = serialPortReadIntoByName( port, count, arrayPtr);
free(port);
_return_value = integerObjectOf(bytesRead);
if (failed()) {
return null;
}
popthenPush(5, _return_value);
return null;
}
primitiveFileRename(void)
{
// FilePlugin>>#primitiveFileRename
char *newNameIndex;
sqInt newNamePointer;
sqInt newNameSize;
sqInt okToRename;
char *oldNameIndex;
sqInt oldNamePointer;
sqInt oldNameSize;
newNamePointer = stackValue(0);
oldNamePointer = stackValue(1);
if (!((isBytes(newNamePointer))
&& (isBytes(oldNamePointer)))) {
return primitiveFail();
}
newNameIndex = firstIndexableField(newNamePointer);
newNameSize = byteSizeOf(newNamePointer);
oldNameIndex = firstIndexableField(oldNamePointer);
/* If the security plugin can be loaded, use it to check for rename permission.
If not, assume it's ok */
oldNameSize = byteSizeOf(oldNamePointer);
if (sCRFfn != 0) {
okToRename = ((sqInt (*)(char *, sqInt))sCRFfn)(oldNameIndex, oldNameSize);
if (!okToRename) {
return primitiveFail();
}
}
sqFileRenameOldSizeNewSize(oldNameIndex, oldNameSize, newNameIndex, newNameSize);
if (!(failed())) {
pop(2);
}
}
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));
}
}
EXPORT(sqInt) primitiveCompressToByteArray(void) {
sqInt eqBytes;
sqInt i;
sqInt j;
sqInt k;
sqInt lowByte;
sqInt m;
sqInt size;
sqInt word;
sqInt j1;
sqInt j2;
sqInt j3;
sqInt j4;
sqInt j5;
sqInt j6;
sqInt j7;
sqInt rcvr;
int *bm;
unsigned char *ba;
rcvr = stackValue(2);
bm = arrayValueOf(stackValue(1));
bm -= 1;
if (!(isBytes(stackValue(0)))) {
return primitiveFail();
}
ba = arrayValueOf(stackValue(0));
ba -= 1;
if (!(successFlag)) {
return null;
}
size = sizeOfSTArrayFromCPrimitive(bm + 1);
/* begin encodeInt:in:at: */
if (size <= 223) {
ba[1] = size;
i = 1 + 1;
goto l5;
}
if (size <= 7935) {
ba[1] = ((((sqInt) size >> 8)) + 224);
ba[1 + 1] = (size % 256);
i = 1 + 2;
goto l5;
}
primitiveOSSocketHandle(void)
{
int fileNo;
sqInt sqSocketOop;
sqSocketOop = stackValue(0);
if (!(((isBytes(sqSocketOop))
&& ((byteSizeOf(sqSocketOop)) == (sizeof(SQSocket))))
&& (!(isNullSQSocket(sqSocketOop))))) {
return primitiveFail();
}
fileNo = socketDescriptorFrom(sqSocketOop);
if (fileNo < 0) {
return primitiveFail();
}
pop(2);
pushInteger(fileNo);
return 0;
}
primitiveSerialPortOpenByName(void)
{
// SerialPlugin>>#primitiveSerialPortOpenByName
sqInt baudRate;
sqInt dataBits;
sqInt inFlowControl;
sqInt outFlowControl;
sqInt parityType;
char *port;
char *portName;
sqInt portNameSize;
sqInt stopBitsType;
sqInt xOffChar;
sqInt xOnChar;
success(isBytes(stackValue(8)));
portName = ((char *) (firstIndexableField(stackValue(8))));
baudRate = stackIntegerValue(7);
stopBitsType = stackIntegerValue(6);
parityType = stackIntegerValue(5);
dataBits = stackIntegerValue(4);
inFlowControl = stackIntegerValue(3);
outFlowControl = stackIntegerValue(2);
xOnChar = stackIntegerValue(1);
xOffChar = stackIntegerValue(0);
if (failed()) {
return null;
}
portNameSize = slotSizeOf(((int) portName) - 4);
port = calloc(portNameSize+1, sizeof(char));
memcpy(port, portName, portNameSize);
serialPortOpenByName(
port, baudRate, stopBitsType, parityType, dataBits,
inFlowControl, outFlowControl, xOnChar, xOffChar);
free(port);
if (failed()) {
return null;
}
pop(9);
return null;
}
primitiveAsyncFileOpen(void)
{
// AsynchFilePlugin>>#primitiveAsyncFileOpen
AsyncFile *f;
char *fileName;
sqInt fileNameSize;
sqInt fOop;
sqInt okToOpen;
sqInt semaIndex;
sqInt writeFlag;
success(isBytes(stackValue(2)));
fileName = ((char *) (firstIndexableField(stackValue(2))));
writeFlag = booleanValueOf(stackValue(1));
semaIndex = stackIntegerValue(0);
if (failed()) {
return null;
}
/* If the security plugin can be loaded, use it to check for permission.
If not, assume it's ok */
fileNameSize = slotSizeOf(((int) fileName) - 4);
if (sCOAFfn != 0) {
okToOpen = ((sqInt (*) (char *, sqInt, sqInt)) sCOAFfn)(fileName, fileNameSize, writeFlag);
if (!okToOpen) {
primitiveFail();
return null;
}
}
fOop = instantiateClassindexableSize(classByteArray(), sizeof(AsyncFile));
f = asyncFileValueOf(fOop);
if (!(failed())) {
asyncFileOpen(f, (int)fileName, fileNameSize, writeFlag, semaIndex);
}
if (failed()) {
return null;
}
popthenPush(4, fOop);
return null;
}
