VOID Map<K,V,KeyElementTraits, ValueElementTraits, ThreadingModel>::RemoveAll()
{
Node* pNode = m_pRoot;
while (pNode != m_pNil)
{
if (!IsNil(pNode->m_pLeft))
{
pNode = pNode->m_pLeft;
SetNil( &pNode->m_pParent->m_pLeft );
}
else if (!IsNil(pNode->m_pRight))
{
pNode = pNode->m_pRight;
SetNil( &pNode->m_pParent->m_pRight );
}
else
{
Node* pParent = pNode->m_pParent;
delete pNode;
pNode = pParent;
}
}
m_NodeCount = 0;
SetNil(&m_pRoot);
}
int prDirectory_At(struct VMGlobals *g, int numArgsPushed)
{
PyrSlot *a = g->sp - 2;
PyrSlot *b = g->sp - 1;
PyrSlot *c = g->sp;
PyrSlot *dirPathSlot = slotRawObject(a)->slots + 0;
int err, index;
err = slotIntVal(c, &index);
if (err) {
SetNil(a);
return err;
}
char name[256], fullPathName[256];
int nameLength, creationDate, modificationDate, isDirectory, isVisible, sizeIfFile;
int dirPathLength = slotRawObject(dirPathSlot)->size;
err = dir_Lookup(slotRawObject(dirPathSlot)s->s, dirPathLength, index+1,
name, &nameLength, &creationDate, &modificationDate, &isDirectory, &isVisible, &sizeIfFile);
if (err == 1) {
SetNil(a);
return errNone;
}
if (err) {
error("Invalid path\n");
SetNil(a);
return errFailed;
}
if (dirPathLength + nameLength + 1 > 255) {
error("Full path name too long.\n");
SetNil(a);
return errFailed;
}
PyrSlot *entryName = slotRawObject(b)->slots + 0;
PyrSlot *entryPath = slotRawObject(b)->slots + 1;
PyrSlot *entryIsDir = slotRawObject(b)->slots + 2;
PyrSlot *entryIsVisible = slotRawObject(b)->slots + 3;
PyrString *nameString = newPyrString(g->gc, name, 0, true);
SetObject(entryName, nameString);
g->gc->GCWrite(slotRawObject(b), (PyrObject*)nameString);
memcpy(fullPathName, slotRawObject(dirPathSlot)s->s, dirPathLength);
fullPathName[dirPathLength] = DELIMITOR;
strcpy(fullPathName + dirPathLength + 1, name);
PyrString *pathString = newPyrString(g->gc, fullPathName, 0, true);
SetObject(entryPath, pathString);
g->gc->GCWrite(slotRawObject(b), (PyrObject*)pathString);
if (isDirectory) { SetTrue(entryIsDir); } else { SetFalse(entryIsDir); }
if (isVisible) { SetTrue(entryIsVisible); } else { SetFalse(entryIsVisible); }
slotCopy(a,b);
return errNone;
}
static void _doc_traverse(struct VMGlobals* g, DocNode *n, PyrObject *parent, PyrSlot *slot)
{
PyrObject *result = instantiateObject( g->gc, s_scdoc_node->u.classobj, 0, false, false );
result->size = 0;
SetObject(slot, result);
if(parent) g->gc->GCWrite(parent, result);
PyrSymbol *id = getsym(n->id);
SetSymbol(result->slots+result->size++, id);
if(n->text) {
PyrObject *str = (PyrObject*) newPyrString(g->gc, n->text, 0, true);
SetObject(result->slots+result->size++, str);
g->gc->GCWrite(result, str);
} else {
SetNil(result->slots+result->size++);
}
if(n->n_childs) {
PyrObject *array = newPyrArray(g->gc, n->n_childs, 0, true);
array->size = 0;
SetObject(result->slots+result->size++, array);
g->gc->GCWrite(result, array);
for(int i=0; i<n->n_childs; i++) {
array->size++;
_doc_traverse(g, n->children[i], array, array->slots+i);
}
} else {
SetNil(result->slots+result->size++);
}
result->size += 3; // makeDiv, notPrivOnly, sort
}
VOID Set<K,ElementTraits>::RemoveAll()
{
Node* pNode = m_pRoot;
while (pNode != m_pNil)
{
if (!IsNil(pNode->m_pLeft))
{
pNode = pNode->m_pLeft;
SetNil( &pNode->m_pParent->m_pLeft );
}
else if (!IsNil(pNode->m_pRight))
{
pNode = pNode->m_pRight;
SetNil( &pNode->m_pParent->m_pRight );
}
else
{
Node* pParent = pNode->m_pParent;
delete pNode;
pNode = pParent;
}
}
m_NodeCount = 0;
SetNil(&m_pRoot);
}
int prFile_PutFile(struct VMGlobals *g, int numArgsPushed)
{
PyrSlot *a = g->sp - 2;
PyrSlot *b = g->sp - 1;
PyrSlot *c = g->sp;
NavDialogOptions options;
int err = NavGetDefaultDialogOptions(&options);
if (err) return errFailed;
options.dialogOptionFlags |= kNavNoTypePopup;
options.dialogOptionFlags |= kNavDontAutoTranslate;
options.dialogOptionFlags |= kNavDontAddTranslateItems;
options.dialogOptionFlags |= kNavSelectDefaultLocation;
options.dialogOptionFlags &= ~kNavAllowPreviews;
options.dialogOptionFlags &= ~kNavAllowMultipleFiles;
if (isKindOfSlot(b, class_string)) {
pstringFromPyrString((PyrString*)slotRawObject(b), options.message, 256);
}
if (isKindOfSlot(c, class_string)) {
pstringFromPyrString((PyrString*)slotRawObject(c), options.savedFileName, 256);
} else {
//pstrncpy(options.savedFileName, "\pUntitled", 255);
}
NavReplyRecord reply;
err = NavPutFile(0, &reply, &options, 0, 'TEXT', 'SCjm', 0);
if (err == noErr && reply.validRecord) {
AEKeyword keyword;
DescType actualType;
Size actualSize;
FSSpec fsspec;
err = AEGetNthPtr(&reply.selection, 1, typeFSS, &keyword, &actualType,
&fsspec, sizeof(FSSpec), &actualSize);
if (err == noErr) {
Str255 pathname;
GetFullPathname(&fsspec, pathname);
p2cstr(pathname);
PyrString *string = newPyrString(g->gc, (char*)pathname, 0, true);
SetObject(a, string);
err = NavCompleteSave(&reply, kNavTranslateInPlace);
} else {
SetNil(a);
}
err = NavDisposeReply(&reply);
} else {
SetNil(a);
}
return errNone;
}
void PyrGC::Finalize(PyrObject *finalizer)
{
if (!IsPtr(finalizer->slots+0)) return;
if (!IsObj(finalizer->slots+1)) return;
ObjFuncPtr func = (ObjFuncPtr)finalizer->slots[0].ui;
PyrObject *obj = finalizer->slots[1].uo;
//post("FINALIZE %s %p\n", obj->classptr->name.us->name, obj);
(func)(mVMGlobals, obj);
SetNil(obj->slots+0);
SetNil(obj->slots+1);
}
void PyrGC::Finalize(PyrObject *finalizer)
{
if (!IsPtr(finalizer->slots+0)) return;
if (!IsObj(finalizer->slots+1)) return;
ObjFuncPtr func = (ObjFuncPtr)slotRawPtr(&finalizer->slots[0]);
PyrObject *obj = slotRawObject(&finalizer->slots[1]);
//post("FINALIZE %s %p\n", slotRawSymbol(&obj->classptr->name)->name, obj);
(func)(mVMGlobals, obj);
SetNil(obj->slots+0);
SetNil(obj->slots+1);
}
void PriorityQueuePop(VMGlobals *g, PyrObject *queueobj, PyrSlot *result)
{
PyrSlot *schedqSlot = queueobj->slots;
if (IsObj(schedqSlot)) {
PyrObject *schedq = slotRawObject(schedqSlot);
double time;
if (!getheap(g, schedq, &time, result)) {
SetNil(result);
}
} else {
SetNil(result);
}
}
void PriorityQueueTop(PyrObject *queueobj, PyrSlot *result)
{
PyrSlot *schedqSlot = queueobj->slots;
if (IsObj(schedqSlot)) {
PyrObject *schedq = slotRawObject(schedqSlot);
if (schedq->size > 1) {
slotCopy(result,&schedq->slots[1]);
} else {
SetNil(result);
}
} else {
SetNil(result);
}
}
PyrGC::PyrGC(VMGlobals *g, AllocPool *inPool, PyrClass *mainProcessClass, long poolSize)
{
mVMGlobals = g;
mPool = inPool;
//mCurSet = 0;
mNumToScan = 0;
mFlips = 0;
mCollects = 0;
mAllocTotal = 0;
mNumAllocs = 0;
mScans = 0;
mStackScans = 0;
mNumPartialScans = 0;
mSlotsScanned = 0;
mGreyColor = 3<<2;
mBlackColor = 2<<2;
mWhiteColor = 1<<2;
mFreeColor = 0;
mRunning = false;
mCanSweep = false;
mPartialScanObj = NULL;
mPartialScanSlot = 0;
mGrey.classptr = NULL;
mGrey.obj_sizeclass = 0;
mGrey.size = 0;
mGrey.gc_color = obj_gcmarker;
mGrey.prev = &mGrey;
mGrey.next = &mGrey;
mNumGrey = 0;
mNewPool.Init(mPool, poolSize, poolSize, 9000);
// initialize treadmills
for (int i=0; i<kNumGCSets; ++i) {
mSets[i].Init(i);
}
mProcess = newPyrProcess(g, mainProcessClass);
mStack = mProcess->mainThread.uot->stack.uo;
ToBlack(mStack);
SetNil(&mProcess->mainThread.uot->stack);
mNumGrey = 0;
ToGrey2(mProcess);
g->sp = mStack->slots - 1;
g->process = mProcess;
mRunning = true;
SanityCheck();
//assert(SanityCheck());
}
int prIsPrime(VMGlobals *g, int numArgsPushed)
{
PyrSlot *a;
int n, p, sqrtn, i;
a = g->sp;
n = slotRawInt(a);
SetNil(a);
if (n <= 2) {
if (n == 2) { SetTrue(a); }
else { SetFalse(a); }
} else if (n <= nthPrime(NUMPRIMES-1)) {
// do a search of the primes table
i = findPrime(n);
if (i >= 0) { SetTrue(a); }
else { SetFalse(a); }
} else {
#ifdef SC_WIN32
sqrtn = (int)sqrt(static_cast<double>(n));
#else
sqrtn = (int)sqrt(n);
#endif
for (i=0; i<NUMPRIMES; ++i) {
p = nthPrime(i);
if (n % p == 0) { SetFalse(a); break; }
if (p >= sqrtn) { SetTrue(a); break; }
}
}
return errNone;
}
int prPipeOpen(struct VMGlobals *g, int numArgsPushed)
{
PyrSlot *a, *b, *c;
char mode[12];
PyrFile *pfile;
FILE *file;
a = g->sp - 2;
b = g->sp - 1;
c = g->sp;
if (NotObj(c) || !isKindOf(slotRawObject(c), class_string)
|| NotObj(b) || !isKindOf(slotRawObject(b), class_string))
return errWrongType;
if (slotRawObject(c)->size > 11) return errFailed;
pfile = (PyrFile*)slotRawObject(a);
char *commandLine = (char*)malloc(slotRawObject(b)->size + 1);
memcpy(commandLine, slotRawString(b)->s, slotRawObject(b)->size);
commandLine[slotRawString(b)->size] = 0;
memcpy(mode, slotRawString(c)->s, slotRawObject(c)->size);
mode[slotRawString(c)->size] = 0;
pid_t pid;
file = sc_popen(commandLine, &pid, mode);
free(commandLine);
if (file) {
SetPtr(&pfile->fileptr, file);
SetInt(a, pid);
} else {
SetNil(a);
}
return errNone;
}
extern size_t XML_UnPackValue(CONVOPT *opt, unsigned char *p,
ValueStruct *value) {
ValueContext *ctx;
unsigned char *pp;
ctx = New(ValueContext);
ctx->root = value;
ctx->buff = (xmlChar *)xmalloc(1);
ctx->size = 1;
ctx->fStart = FALSE;
ctx->opt = opt;
ctx->value = NULL;
memset(ctx->longname, 0, SIZE_LONGNAME + 1);
SetNil(value);
pp = p;
switch (ConvXmlType(opt)) {
case XML_TYPE1:
xmlSAXUserParseMemory(mondaiSAXHandler1, ctx, (char *)p, strlen((char *)p));
break;
case XML_TYPE2:
xmlSAXUserParseMemory(mondaiSAXHandler2, ctx, (char *)p, strlen((char *)p));
break;
}
xmlCleanupParser();
xfree(ctx->buff);
xfree(ctx);
return (p - pp);
}
int prSCDoc_ParseFile(struct VMGlobals* g, int numArgsPushed)
{
PyrSlot *a, *b, *c;
char filename[PATH_MAX];
int mode, err;
a = g->sp - 2;
b = g->sp - 1;
c = g->sp;
err = slotStrVal(b, filename, PATH_MAX);
if (err) return err;
err = slotIntVal(c, &mode);
if (err) return err;
DocNode *n = scdoc_parse_file(filename, mode);
if(n) {
// doc_node_dump(n);
_doc_traverse(g, n, NULL, a);
doc_node_free_tree(n);
} else {
SetNil(a);
}
return errNone;
}
typename Map<K,V,KeyElementTraits, ValueElementTraits, ThreadingModel>::Node* Map<K,V,KeyElementTraits, ValueElementTraits, ThreadingModel>::Insert( CONST K& Key, CONST V& Value )
{
Node* pNewNode = InsertImpl( Key, Value );
Node* pX = pNewNode;
pX->m_Status = Node::Red;
Node* pY = 0;
while (pX != m_pRoot && pX->m_pParent->m_Status == Node::Red)
{
if (pX->m_pParent == pX->m_pParent->m_pParent->m_pLeft)
{
pY = pX->m_pParent->m_pParent->m_pRight;
if (pY != NULL && pY->m_Status == Node::Black)
{
pX->m_pParent->m_Status = Node::Black;
pY->m_Status = Node::Black;
pX->m_pParent->m_pParent->m_Status = Node::Red;
pX = pX->m_pParent->m_pParent;
}
else
{
if (pX == pX->m_pParent->m_pRight)
{
pX = pX->m_pParent;
LeftRotate(pX);
}
pX->m_pParent->m_Status = Node::Black;
pX->m_pParent->m_pParent->m_Status = Node::Red;
RightRotate(pX->m_pParent->m_pParent);
}
}
else
{
pY = pX->m_pParent->m_pParent->m_pLeft;
if (pY != NULL && pY->m_Status == Node::Red)
{
pX->m_pParent->m_Status = Node::Black;
pY->m_Status = Node::Black;
pX->m_pParent->m_pParent->m_Status = Node::Red;
pX = pX->m_pParent->m_pParent;
}
else
{
if (pX == pX->m_pParent->m_pLeft)
{
pX = pX->m_pParent;
RightRotate(pX);
}
pX->m_pParent->m_Status = Node::Black;
pX->m_pParent->m_pParent->m_Status = Node::Red;
LeftRotate(pX->m_pParent->m_pParent);
}
}
}
m_pRoot->m_Status = Node::Black;
SetNil(&m_pRoot->m_pParent);
return pNewNode;
}
int prHIDGetValue(VMGlobals *g, int numArgsPushed)
{
PyrSlot *a = g->sp - 2; //class
PyrSlot *b = g->sp - 1; //locID device
PyrSlot *c = g->sp; //element cookie
int locID, cookieNum;
int err = slotIntVal(b, &locID);
if (err) return err;
err = slotIntVal(c, &cookieNum);
if (err) return err;
IOHIDElementCookie cookie = (IOHIDElementCookie) cookieNum;
//look for the right device:
pRecDevice pCurrentHIDDevice = HIDGetFirstDevice ();
while (pCurrentHIDDevice && (pCurrentHIDDevice->locID !=locID))
pCurrentHIDDevice = HIDGetNextDevice (pCurrentHIDDevice);
if(!pCurrentHIDDevice) return errFailed;
//look for the right element:
pRecElement pCurrentHIDElement = HIDGetFirstDeviceElement (pCurrentHIDDevice, kHIDElementTypeAll);
// use gElementCookie to find current element
while (pCurrentHIDElement && (pCurrentHIDElement->cookie != cookie))
pCurrentHIDElement = HIDGetNextDeviceElement (pCurrentHIDElement, kHIDElementTypeAll);
if (pCurrentHIDElement)
{
SInt32 value = HIDGetElementValue (pCurrentHIDDevice, pCurrentHIDElement);
// if it's not a button and it's not a hatswitch then calibrate
if(( pCurrentHIDElement->type != kIOHIDElementTypeInput_Button ) &&
( pCurrentHIDElement->usagePage == 0x01 && pCurrentHIDElement->usage != kHIDUsage_GD_Hatswitch))
value = HIDCalibrateValue ( value, pCurrentHIDElement );
SetInt(a, value);
}
else SetNil(a);
return errNone;
}
int prAscTime(struct VMGlobals *g, int numArgsPushed)
{
PyrSlot *a = g->sp;
PyrSlot *slots = a->uo->slots;
if (IsNil(slots + 0)) {
SetNil(a);
return errNone;
}
struct tm tm0;
if (slotIntVal(slots+0, &tm0.tm_year)) return errWrongType;
tm0.tm_year -= 1900;
if (slotIntVal(slots+1, &tm0.tm_mon)) return errWrongType;
tm0.tm_mon -- ;
if (slotIntVal(slots+2, &tm0.tm_mday)) return errWrongType;
if (slotIntVal(slots+3, &tm0.tm_hour)) return errWrongType;
if (slotIntVal(slots+4, &tm0.tm_min)) return errWrongType;
if (slotIntVal(slots+5, &tm0.tm_sec)) return errWrongType;
if (slotIntVal(slots+6, &tm0.tm_wday)) return errWrongType;
const char *text = asctime(&tm0);
int size = strlen(text) - 1; // Discard trailing newline
PyrString *strobj = newPyrStringN(g->gc, size, 0, true);
memcpy(strobj->s, text, size);
SetObject(a, strobj);
return errNone;
}
void VM::Return(Value *a, Instruction i)
{
// Set stack top when return value count is fixed
int ret_value_count = Instruction::GetParamsBx(i);
if (ret_value_count != EXP_VALUE_COUNT_ANY)
state_->stack_.top_ = a + ret_value_count;
assert(!state_->calls_.empty());
auto call = &state_->calls_.back();
auto src = a;
auto dst = call->func_;
int expect_result = call->expect_result_;
int result_count = state_->stack_.top_ - src;
if (expect_result == EXP_VALUE_COUNT_ANY)
{
for (int i = 0; i < result_count; ++i)
*dst++ = *src++;
}
else
{
int i = 0;
int count = std::min(expect_result, result_count);
for (; i < count; ++i)
*dst++ = *src++;
// No enough results for expect results, set remain as nil
for (; i < expect_result; ++i, ++dst)
dst->SetNil();
}
// Set new top and pop current CallInfo
state_->stack_.SetNewTop(dst);
state_->calls_.pop_back();
}
typename Set<K,ElementTraits>::Node* Set<K,ElementTraits>::Insert( CONST K& Key )
{
Node* pNewNode = InsertImpl( Key );
Node* pX = pNewNode;
pX->m_Status = Node::Red;
Node* pY = 0;
while (pX != m_pRoot && pX->m_pParent->m_Status == Node::Red)
{
if (pX->m_pParent == pX->m_pParent->m_pParent->m_pLeft)
{
pY = pX->m_pParent->m_pParent->m_pRight;
if (pY != NULL && pY->m_Status == Node::Black)
{
pX->m_pParent->m_Status = Node::Black;
pY->m_Status = Node::Black;
pX->m_pParent->m_pParent->m_Status = Node::Red;
pX = pX->m_pParent->m_pParent;
}
else
{
if (pX == pX->m_pParent->m_pRight)
{
pX = pX->m_pParent;
LeftRotate(pX);
}
pX->m_pParent->m_Status = Node::Black;
pX->m_pParent->m_pParent->m_Status = Node::Red;
RightRotate(pX->m_pParent->m_pParent);
}
}
else
{
pY = pX->m_pParent->m_pParent->m_pLeft;
if (pY != NULL && pY->m_Status == Node::Red)
{
pX->m_pParent->m_Status = Node::Black;
pY->m_Status = Node::Black;
pX->m_pParent->m_pParent->m_Status = Node::Red;
pX = pX->m_pParent->m_pParent;
}
else
{
if (pX == pX->m_pParent->m_pLeft)
{
pX = pX->m_pParent;
RightRotate(pX);
}
pX->m_pParent->m_Status = Node::Black;
pX->m_pParent->m_pParent->m_Status = Node::Red;
LeftRotate(pX->m_pParent->m_pParent);
}
}
}
m_pRoot->m_Status = Node::Black;
SetNil(&m_pRoot->m_pParent);
return pNewNode;
}
int finalize_image_object( struct VMGlobals *g, struct PyrObject *obj )
{
SharedImage *shared_image_ptr =
reinterpret_cast<SharedImage*>( slotRawPtr(obj->slots) );
delete shared_image_ptr;
SetNil( obj->slots+0 );
return errNone;
}
void QcTreeWidget::Item::initialize (
VMGlobals *g, PyrObject *obj, const QcTreeWidget::ItemPtr &ptr )
{
Q_ASSERT( isKindOf( obj, SC_CLASS(TreeViewItem) ) );
if( ptr.id() ) {
// store the SafePtr
QcTreeWidget::ItemPtr *newPtr = new QcTreeWidget::ItemPtr( ptr );
SetPtr( obj->slots+0, newPtr );
// store the id for equality comparison
SetPtr( obj->slots+1, ptr.id() );
// install finalizer
}
else {
SetNil( obj->slots+0 );
SetNil( obj->slots+1 );
}
InstallFinalizer( g, obj, 2, &QcTreeWidget::Item::finalize );
}
int prHIDSetValue(VMGlobals *g, int numArgsPushed)
{
PyrSlot *a = g->sp - 3; //class
PyrSlot *b = g->sp - 2; //locID
PyrSlot *c = g->sp - 1; //element device
PyrSlot *d = g->sp; //value cookie
int locID, cookieNum, value;
int err = slotIntVal(b, &locID);
if (err) return err;
err = slotIntVal(c, &cookieNum);
if (err) return err;
IOHIDElementCookie cookie = (IOHIDElementCookie) cookieNum;
err = slotIntVal(d, &value);
if (err) return err;
//look for the right device:
pRecDevice pCurrentHIDDevice = HIDGetFirstDevice ();
while (pCurrentHIDDevice && (pCurrentHIDDevice->locID !=locID))
pCurrentHIDDevice = HIDGetNextDevice (pCurrentHIDDevice);
if(!pCurrentHIDDevice) return errFailed;
//look for the right element:
pRecElement pCurrentHIDElement = HIDGetFirstDeviceElement (pCurrentHIDDevice, kHIDElementTypeAll);
// use gElementCookie to find current element
while (pCurrentHIDElement && (pCurrentHIDElement->cookie != cookie))
pCurrentHIDElement = HIDGetNextDeviceElement (pCurrentHIDElement, kHIDElementTypeAll);
//struct IOHIDEventStruct
//{
// IOHIDElementType type;
// IOHIDElementCookie elementCookie;
// SInt32 value;
// AbsoluteTime timestamp;
// UInt32 longValueSize;
// void * longValue;
//};
if (pCurrentHIDElement)
{
IOHIDEventStruct event =
{
kIOHIDElementTypeOutput,
pCurrentHIDElement->cookie,
value,
{0},
sizeof(int),
NULL
};
SInt32 value = HIDSetElementValue (pCurrentHIDDevice, pCurrentHIDElement, &event);
// if it's not a button and it's not a hatswitch then calibrate
// if(( pCurrentHIDElement->type != kIOHIDElementTypeInput_Button ) &&
// ( pCurrentHIDElement->usagePage == 0x01 && pCurrentHIDElement->usage != kHIDUsage_GD_Hatswitch))
// value = HIDCalibrateValue ( value, pCurrentHIDElement );
SetInt(a, value);
}
else SetNil(a);
return errNone;
}
int prTempoClock_Free(struct VMGlobals *g, int numArgsPushed)
{
PyrSlot *a = g->sp;
TempoClock *clock = (TempoClock*)slotRawPtr(&slotRawObject(a)->slots[1]);
if (!clock) return errNone; // not running
SetNil(slotRawObject(a)->slots + 1);
clock->StopReq();
return errNone;
}
static void SetNil(ValueStruct *val) {
int i;
switch (ValueType(val)) {
case GL_TYPE_ARRAY:
for (i = 0; i < ValueArraySize(val); i++) {
SetNil(ValueArrayItem(val, i));
}
break;
case GL_TYPE_ROOT_RECORD:
case GL_TYPE_RECORD:
for (i = 0; i < ValueRecordSize(val); i++) {
SetNil(ValueRecordItem(val, i));
}
break;
default:
ValueIsNil(val);
break;
}
}
int prSymbolClass(struct VMGlobals *g, int numArgsPushed)
{
PyrSlot *a;
PyrClass *classobj;
//char firstChar;
a = g->sp;
if (slotRawSymbol(a)->flags & sym_Class) {
//firstChar = slotRawSymbol(a)->name[0];
//if (firstChar >= 'A' && firstChar <= 'Z') {
classobj = slotRawSymbol(a)->u.classobj;
if (classobj) {
SetObject(a, classobj);
} else {
SetNil(a);
}
} else {
SetNil(a);
}
return errNone;
}
int prIdentDict_PutGet(struct VMGlobals *g, int numArgsPushed)
{
PyrSlot *a, *b, *c, *d, *slot, *newslot;
int i, index, size;
PyrObject *dict;
PyrObject *array;
a = g->sp - 2; // dict
b = g->sp - 1; // key
c = g->sp; // value
d = ++g->sp; // push the stack to save the receiver
slotCopy(d,a);
dict = slotRawObject(d);
array = slotRawObject(&dict->slots[ivxIdentDict_array]);
if (!isKindOf((PyrObject*)array, class_array)) {
SetNil(a);
--g->sp;
return errFailed;
}
index = arrayAtIdentityHashInPairs(array, b);
slot = array->slots + index;
slotCopy(a,&slot[1]);
slotCopy(&slot[1],c);
g->gc->GCWrite(array, c);
if (IsNil(slot)) {
slotCopy(slot,b);
g->gc->GCWrite(array, b);
size = slotRawInt(&dict->slots[ivxIdentDict_size]) + 1;
SetRaw(&dict->slots[ivxIdentDict_size], size);
if (array->size < size*3) {
PyrObject *newarray;
newarray = newPyrArray(g->gc, size*3, 0, true);
newarray->size = ARRAYMAXINDEXSIZE(newarray);
nilSlots(newarray->slots, newarray->size);
slot = array->slots;
for (i=0; i<array->size; i+=2, slot+=2) {
if (NotNil(slot)) {
index = arrayAtIdentityHashInPairs(newarray, slot);
newslot = newarray->slots + index;
slotCopy(&newslot[0],&slot[0]);
slotCopy(&newslot[1],&slot[1]);
}
}
SetRaw(&dict->slots[ivxIdentDict_array], newarray);
g->gc->GCWriteNew(dict, newarray); // we know newarray is white so we can use GCWriteNew
}
}
--g->sp;
return errNone;
}
int prIndexOfPrime(VMGlobals *g, int numArgsPushed)
{
PyrSlot *a;
int n, p;
a = g->sp;
n = slotRawInt(a);
if (n <= 2) {
if (n == 2) { SetInt(a, 0); }
else { SetNil(a); }
} else if (n <= nthPrime(NUMPRIMES-1)) {
p = findPrime(n);
if (p < 0) {
SetNil(a);
} else {
SetInt(a, p);
}
} else {
SetNil(a);
}
return errNone;
}
int prSFClose(struct VMGlobals *g, int numArgsPushed)
{
PyrSlot *a;
a = g->sp;
SNDFILE *file = (SNDFILE*)slotRawPtr(&slotRawObject(a)->slots[0]);
if (file) {
sf_close(file);
SetNil(slotRawObject(a)->slots + 0);
}
return errNone;
}
int prNthPrime(VMGlobals *g, int numArgsPushed)
{
PyrSlot *a;
int n, p;
a = g->sp;
n = slotRawInt(a);
p = nthPrime(n);
if (p == 0) {
SetNil(a);
} else {
SetInt(a, p);
}
return errNone;
}
static int prSerialPort_Cleanup(struct VMGlobals *g, int numArgsPushed)
{
PyrSlot* self = g->sp;
SerialPort* port = (SerialPort*)getSerialPort(self);
if (port == 0) return errFailed;
port->cleanup();
post("SerialPort Cleanup\n");
delete port;
SetNil(slotRawObject(self)->slots+0);
return errNone;
}