int prTempoClock_New(struct VMGlobals *g, int numArgsPushed)
{
PyrSlot *a = g->sp - 3;
PyrSlot *b = g->sp - 2;
PyrSlot *c = g->sp - 1;
PyrSlot *d = g->sp;
double tempo;
int err = slotDoubleVal(b, &tempo);
if (err) tempo = 1.;
if (tempo <= 0.) {
error("invalid tempo %g\n", tempo);
SetPtr(slotRawObject(a)->slots+1, NULL);
return errFailed;
}
double beats;
err = slotDoubleVal(c, &beats);
if (err) beats = 0.;
double seconds;
err = slotDoubleVal(d, &seconds);
if (err) seconds = elapsedTime();
TempoClock* clock = new TempoClock(g, slotRawObject(a), tempo, beats, seconds);
SetPtr(slotRawObject(a)->slots+1, clock);
return errNone;
}
void NetNode::SetPtrs()
{
SetPtr(local, net.lpLocalName);
SetPtr(remote, net.lpRemoteName);
SetPtr(comment, net.lpComment);
SetPtr(provider, net.lpProvider);
}
/** Sets the start point of the read and/or the write area within the intermediate
buffer.
A start point is always within an area.
@param anArea The areas within the intermediate buffer for which the start
point is to be set. These can be the read area and/or the write area, as indicated
by the ERead and EWrite bits. Only these bits can be set, otherwise the function
raises a STORE-Stream 17 panic.
@param aPtr The start point.
@see MStreamBuf::TRead
@see MStreamBuf::TWrite */
EXPORT_C void TStreamBuf::SetPtr(TArea anArea,TUint8* aPtr)
{
__ASSERT_ALWAYS(!(anArea&~(ERead|EWrite)),Panic(EStreamAreaInvalid));
if (anArea&ERead)
SetPtr(ERead,aPtr);
if (anArea&EWrite)
SetPtr(EWrite,aPtr);
}
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;
}
void initialize_image_object( struct VMGlobals *g, struct PyrObject *obj, Image *image )
{
assert( IsNil( obj->slots ) && IsNil( obj->slots+1 ) );
SharedImage *shared_image_ptr = new SharedImage(image);
SetPtr( obj->slots, shared_image_ptr ); // dataptr
InstallFinalizer( g, obj, 1, finalize_image_object ); // finalizer
}
/** Writes data from the specified memory location into the intermediate buffer.
The function calls the virtual function OverfLowL() to give concrete implementations
the chance to forward the intermediate buffer content to its destination.
This implementation overrides the one supplied by the base class MStreamBuf,
and is called by MStreamBuf::WriteL(const TAny*,TInt).
@param aPtr A pointer to the source memory location for the data to be written
to the intermediate buffer.
@param aLength The number of bytes to be written.
@return The number of bytes written.
@see MStreamBuf::WriteL()
@see MStreamBuf::DoWriteL() */
EXPORT_C void TStreamBuf::DoWriteL(const TAny* aPtr,TInt aLength)
{
__ASSERT_DEBUG(aLength>=0,Panic(EStreamWriteLengthNegative));
__ASSERT_DEBUG(aLength>0,Panic(EStreamWriteNoTransfer));
__ASSERT_DEBUG(Ptr(EWrite)!=NULL||End(EWrite)==NULL,Panic(EStreamCannotWrite));
TInt avail=Avail(EWrite);
__ASSERT_DEBUG(avail>=0,User::Invariant());
if (avail==0)
goto overflow;
//
for(;;)
{
__ASSERT_DEBUG(avail>0,Panic(EStreamOverflowInBreach));
__ASSERT_DEBUG(aLength>0,User::Invariant());
{
TInt len=Min(aLength,avail);
SetPtr(EWrite,Mem::Copy(Ptr(EWrite),aPtr,len));
aLength-=len;
if (aLength==0)
return; // done
//
aPtr=(TUint8*)aPtr+len;
}
//
overflow:
OverflowL();
avail=Avail(EWrite);
};
}
int prConnectSharedMem(VMGlobals *g, int numArgsPushed)
{
#if !defined(SC_IPHONE)
PyrSlot *a = g->sp - 1;
PyrSlot *b = g->sp;
assert(IsObj(a));
PyrObject * self = slotRawObject(a);
int portNumber = slotRawInt(b);
int ptrIndex = 0;
int finalizerIndex = 1;
try {
server_shared_memory_client * client = new server_shared_memory_client(portNumber);
SetPtr(self->slots + ptrIndex, client);
InstallFinalizer(g, self, finalizerIndex, disconnectSharedMem);
postfl("Shared memory server interface initialized\n");
} catch (std::exception & e) {
postfl("Cannot connect to shared memory: %s\n", e.what());
return errFailed;
}
#else
postfl("Warning: Shared memory server interface disabled on iphone\n");
#endif
return errNone;
}
/** Reads data from the intermediate buffer into the specified memory location.
The function calls the virtual function UnderfLowL() to give concrete implementations
the chance to refill the intermediate buffer, and satisfy the caller's requirements.
This implementation overrides the one supplied by the base class MStreamBuf,
and is called by, MStreamBuf::ReadL(TAny*,TInt).
@param aPtr A pointer to the target memory location for the data read from
the intermediate buffer.
@param aMaxLength The maximum number of bytes to be read.
@return The number of bytes read. This may be less than the amount requested.
@see MStreamBuf::ReadL()
@see MStreamBuf::DoReadL() */
EXPORT_C TInt TStreamBuf::DoReadL(TAny* aPtr,TInt aMaxLength)
{
__ASSERT_DEBUG(aMaxLength>=0,Panic(EStreamReadLengthNegative));
__ASSERT_DEBUG(aMaxLength>0,Panic(EStreamReadNoTransfer));
__ASSERT_DEBUG(Ptr(ERead)!=NULL||End(ERead)==NULL,Panic(EStreamCannotRead));
TInt left=aMaxLength;
TInt avail=Avail(ERead);
__ASSERT_DEBUG(avail>=0,User::Invariant());
if (avail==0)
goto underflow;
//
do
{
__ASSERT_DEBUG(avail==Avail(ERead),Panic(EStreamUnderflowInBreach));
__ASSERT_DEBUG(left>0&&avail>0,User::Invariant());
{
TInt len=Min(left,avail);
TUint8* ptr=Ptr(ERead);
aPtr=Mem::Copy(aPtr,ptr,len);
SetPtr(ERead,ptr+len);
left-=len;
if (left==0)
return aMaxLength; // that's it
}
//
underflow:
avail=UnderflowL(left);
} while (avail>0);
__ASSERT_DEBUG(avail==0&&Avail(ERead)==0,Panic(EStreamUnderflowInBreach));
return aMaxLength-left;
}
PyrObject *PyrGC::NewFinalizer(ObjFuncPtr finalizeFunc, PyrObject *inObject, bool inCollect)
{
PyrObject *obj = NULL;
#ifdef GC_SANITYCHECK
SanityCheck();
#endif
// obtain size info
int32 sizeclass = 1;
int32 credit = 1L << sizeclass;
mNumToScan += credit;
mAllocTotal += credit;
mNumAllocs++;
if (inCollect && mNumToScan >= kScanThreshold) {
Collect();
}
GCSet *gcs = mSets + kFinalizerSet;
obj = (PyrObject*)gcs->mFree;
if (!IsMarker(obj)) {
// from free list
gcs->mFree = obj->next;
} else {
if (sizeclass > kMaxPoolSet) {
SweepBigObjects();
int32 allocSize = sizeof(PyrObjectHdr) + (sizeof(PyrSlot) << sizeclass);
obj = (PyrObject*)mPool->Alloc(allocSize);
} else {
int32 allocSize = sizeof(PyrObjectHdr) + (sizeof(PyrSlot) << sizeclass);
obj = (PyrObject*)mNewPool.Alloc(allocSize);
}
if (!obj) {
post("Finalizer alloc failed.\n");
MEMFAILED;
}
DLInsertAfter(&gcs->mWhite, obj);
}
obj->obj_sizeclass = sizeclass;
obj->obj_format = obj_slot;
obj->obj_flags = 0;
obj->size = 2;
obj->classptr = class_finalizer;
obj->gc_color = mWhiteColor;
SetPtr(obj->slots+0, (void*)finalizeFunc);
SetObject(obj->slots+1, inObject);
#ifdef GC_SANITYCHECK
SanityCheck();
#endif
return obj;
}
SC_LID::SC_LID(PyrObject* obj)
: m_next(0),
m_obj(obj),
m_fd(-1),
m_lastEventType(-1)
{
SetPtr(obj->slots+0, this);
}
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 );
}
/////////////////////////////////////////////////////////////////////////////////////////
// DESC: Сохранить альтернативные ветви
// ARGS: rast - объект CSTR_rast
// attr - указатель на структуру CSTR_attr
// out - указатель на FILE
// RETS: TRUE - записано успешно
// FALSE - ошибка
/////////////////////////////////////////////////////////////////////////////////////////
Bool32 CGRAPH_SaveLoop(CSTR_rast rast, CSTR_attr *attr, FILE *out)
{
int32_t i;
intptr_t *ptr;
CSTR_rast curr_rst = rast, next_rst = rast;
ALoop al;
LoopData ld;
if(!CGRAPH_GetLoopCount(&al, curr_rst))
{
wLowRC = CGRAPH_ERR_PARAM;
return FALSE;
}
i = al.n / 3;
fwrite(&i, sizeof(i), 1, out);
for(i = 0; i < al.n; i++)
{
ptr = SetPtr(al.loop, i);
curr_rst = (CSTR_rast)*ptr;
ptr = SetPtr(al.loop, ++i);
next_rst = (CSTR_rast)*ptr;
ptr = SetPtr(al.loop, ++i);
ld.level = *ptr;
if(!CGRAPH_GetLoopData(curr_rst, next_rst, &ld))
{
wLowRC = CGRAPH_ERR_PARAM;
return FALSE;
}
ld.loop = GetCurrLoopCount(next_rst);
fwrite(&ld, sizeof(LoopData), 1, out);
if(!CGRAPH_SaveCSTR(next_rst, attr, out))
return FALSE;
}
free(al.loop);
return TRUE;
}
static int prSerialPort_Open(struct VMGlobals *g, int numArgsPushed)
{
PyrSlot *args = g->sp - 1 - SerialPort::kNumOptions;
int err;
PyrSlot* self = args+0;
if (getSerialPort(self) != 0)
return errFailed;
char portName[PATH_MAX];
err = slotStrVal(args+1, portName, sizeof(portName));
printf("portName %s\n", portName);
if (err) return err;
SerialPort::Options options;
SerialPort* port = 0;
options.exclusive = IsTrue(args+2);
int baudrate;
err = slotIntVal(args+3, &baudrate);
if (err) return err;
options.baudrate = baudrate;
int databits;
err = slotIntVal(args+4, &databits);
if (err) return err;
options.databits = databits;
options.stopbit = IsTrue(args+5);
int parity;
err = slotIntVal(args+6, &parity);
if (err) return err;
options.parity = (SerialPort::Parity)parity;
options.crtscts = IsTrue(args+7);
options.xonxoff = IsTrue(args+8);
try {
port = new SerialPort(slotRawObject(self), portName, options);
} catch (SerialPort::Error& e) {
std::ostringstream os;
os << "SerialPort Error: " << e.what();
post(os.str().c_str());
return errFailed;
}
SetPtr(slotRawObject(self)->slots+0, port);
return errNone;
}
int prFileClose(struct VMGlobals *g, int numArgsPushed)
{
PyrSlot *a;
PyrFile *pfile;
FILE *file;
a = g->sp;
pfile = (PyrFile*)slotRawObject(a);
file = (FILE*)slotRawPtr(&pfile->fileptr);
if (file == NULL) return errNone;
SetPtr(&pfile->fileptr, NULL);
if (fclose(file)) return errFailed;
return errNone;
}
// データ挿入
void push(int value){
__int128 newNode = 0;
__int128 oldNode = 0;
uint64_t newTag = 0;
uint64_t oldTag = 0;
/*--------allocate-------*/
SetPtr(newNode, (Node*)malloc(sizeof(Node)));
GetPtr(newNode)->value = value;
/*--------タグ更新-------*/
do{
oldTag = tagCnt;
newTag = oldTag + 1;
}while(!__sync_bool_compare_and_swap(&tagCnt, oldTag, newTag));
SetTag(newNode, newTag);
SetTag(GetPtr(newNode)->ptr, newTag);
/*--------head更新-------*/
do{
oldNode = head;
SetPtr(GetPtr(newNode)->ptr, GetPtr(oldNode));
}while(!__sync_bool_compare_and_swap(&head, oldNode, newNode));
}
/////////////////////////////////////////////////////////////////////////////////////////
// DESC: Запомнить текущий уровень вложенности в массиве al->loop
// ARGS: al - указатель на ALoop
// level - текущий уровень вложенности
// RETS: TRUE - ОК
// FALSE - нет памяти
/////////////////////////////////////////////////////////////////////////////////////////
Bool32 AddLevel(ALoop *al, intptr_t level)
{
intptr_t *ptr = SetPtr(al->loop, al->n);
*(ptr) = level;
al->n++;
if(al->n == memsize)
{
memsize *= 2;
al->loop = static_cast<intptr_t*> (realloc(al->loop, sizeof(intptr_t) * memsize));
if(!al->loop)
return FALSE;
}
return TRUE;
}
void BWindow_Result::Setup(
Scene_Battle* _pScene,
Game_AliceDollList* _pDollList,
Record_Item* _pItemRecord,
Record_AliceInfo* _pAliceInfo){
pScene = _pScene;
SetFrame(&g_wndSkins.skin[WNDSKIN_DOLLMANAGE], PRESETCOLORSET_BROWN);
SetFrameArea(
WND_MANAGEALICEDOLL_X + WND_RESULT_DX,
WND_MANAGEALICEDOLL_Y + WND_RESULT_DY,
WND_MANAGEALICEDOLL_W - WND_RESULT_DX * 2,
WND_MANAGEALICEDOLL_H - WND_RESULT_DY*2);
SetPtr(_pDollList, _pItemRecord, _pAliceInfo);
w_dollNotice.SetupDefault();
}
/////////////////////////////////////////////////////////////////////////////////////////
// DESC: Запомнить адрес текущего растра в массиве al->loop
// ARGS: al - указатель на ALoop
// rast - текущий растр
// RETS: TRUE - OK
// FALSE - нет памяти
/////////////////////////////////////////////////////////////////////////////////////////
Bool32 AddLoop(ALoop *al, CSTR_rast rast)
{
CSTR_rast rst = rast;
intptr_t *ptr = SetPtr(al->loop, al->n);
*(ptr) = reinterpret_cast<intptr_t> (rst);
al->n++;
if(al->n == memsize)
{
memsize *= 2;
al->loop = static_cast<intptr_t*>(realloc(al->loop, sizeof(intptr_t) * memsize));
if(!al->loop)
return FALSE;
}
return TRUE;
}
int prSFOpenRead(struct VMGlobals *g, int numArgsPushed)
{
PyrSlot *a, *b;
char filename[PATH_MAX];
SNDFILE *file;
SF_INFO info;
const char *headerstr;
const char *sampleformatstr;
a = g->sp - 1;
b = g->sp;
PyrObject *obj1 = slotRawObject(a);
if (!isKindOfSlot(b, class_string)) return errWrongType;
if (slotRawObject(b)->size > PATH_MAX - 1) return errFailed;
memcpy(filename, slotRawString(b)->s, slotRawObject(b)->size);
filename[slotRawString(b)->size] = 0;
info.format = 0;
file = sf_open(filename, SFM_READ, &info);
if (file) {
SetPtr(obj1->slots + 0, file);
sndfileFormatInfoToStrings(&info, &headerstr, &sampleformatstr);
//headerFormatToString(&info, &headerstr);
PyrString *hpstr = newPyrString(g->gc, headerstr, 0, true);
SetObject(obj1->slots+1, hpstr);
g->gc->GCWriteNew(obj1, (PyrObjectHdr*)hpstr); // we know hpstr is white so we can use GCWriteNew
PyrString *smpstr = newPyrString(g->gc, sampleformatstr, 0, true);
SetObject(obj1->slots+2, smpstr);
g->gc->GCWriteNew(obj1, (PyrObjectHdr*)smpstr); // we know smpstr is white so we can use GCWriteNew
SetInt(obj1->slots + 3, info.frames);
SetInt(obj1->slots + 4, info.channels);
SetInt(obj1->slots + 5, info.samplerate);
SetTrue(a);
} else {
SetNil(a);
SetFalse(a);
}
return errNone;
}
//
// Default implementation filling the buffer before turning around to anOutput.
//
EXPORT_C TStreamTransfer TStreamBuf::DoWriteL(MStreamOutput& anOutput,TStreamTransfer aTransfer)
{
__ASSERT_DEBUG(aTransfer>0,Panic(EStreamWriteNoTransfer));
__ASSERT_DEBUG(Ptr(EWrite)!=NULL||End(EWrite)==NULL,Panic(EStreamCannotWrite));
__ASSERT_DEBUG(Avail(EWrite)>=0,User::Invariant());
TInt len=aTransfer[Avail(EWrite)];
if (len>0)
{
__DEBUG(TInt avail=Avail(EWrite)); // may be pulling from this streambuf
TUint8* ptr=Ptr(EWrite);
len=anOutput.PullL(ptr,len);
__ASSERT_DEBUG(len>=0&&len<=aTransfer[avail]&&Ptr(EWrite)==ptr&&Avail(EWrite)>=avail,Panic(EStreamPullInBreach));
SetPtr(EWrite,ptr+len);
aTransfer-=len;
}
if (aTransfer>0)
aTransfer=anOutput.WriteToL(*this,aTransfer);
return aTransfer;
}
/** Reads data from the intermediate buffer and, if necessary, any remaining data
from the stream to the specified target stream input object.
It is called by ReadL(MStreamInput&,TStreamTransfer).
The intermediate buffer is emptied first by calling the target stream input's
PushL() function, which performs the read from intermediate buffer operation.
Any remaining data is then read from the stream by calling the target stream
object's ReadFromL() function, which performs the read from stream operation.
This implementation is called for streams that have buffering capabilities
and are derived from this class.
@param anInput The target stream input object.
@param aTransfer A stream transfer object defining the amount of data available
to be written.
@return The amount of data that was not consumed.
@see MStreamInput::ReadFromL()
@see MStreamInput::PushL() */
EXPORT_C TStreamTransfer TStreamBuf::DoReadL(MStreamInput& anInput,TStreamTransfer aTransfer)
{
__ASSERT_DEBUG(aTransfer>0,Panic(EStreamReadNoTransfer));
__ASSERT_DEBUG(Ptr(ERead)!=NULL||End(ERead)==NULL,Panic(EStreamCannotRead));
__ASSERT_DEBUG(Avail(ERead)>=0,User::Invariant());
TInt len=aTransfer[Avail(ERead)];
if (len>0)
{
__DEBUG(TInt avail=Avail(ERead)); // may be pushing into this streambuf
TUint8* ptr=Ptr(ERead);
len=anInput.PushL(ptr,len);
__ASSERT_DEBUG(len>=0&&len<=aTransfer[avail]&&Ptr(ERead)==ptr&&Avail(ERead)>=avail,Panic(EStreamPushInBreach));
SetPtr(ERead,ptr+len);
aTransfer-=len;
}
if (aTransfer>0)
aTransfer=anInput.ReadFromL(*this,aTransfer);
return aTransfer;
}
static int prNetAddr_Connect(VMGlobals *g, int numArgsPushed)
{
PyrSlot* netAddrSlot = g->sp;
PyrObject* netAddrObj = slotRawObject(netAddrSlot);
int err, port, addr;
err = slotIntVal(netAddrObj->slots + ivxNetAddr_PortID, &port);
if (err) return err;
err = slotIntVal(netAddrObj->slots + ivxNetAddr_Hostaddr, &addr);
if (err) return err;
try {
SC_TcpClientPort *comPort = new SC_TcpClientPort(addr, port, netAddrTcpClientNotifyFunc, netAddrObj);
SetPtr(netAddrObj->slots + ivxNetAddr_Socket, comPort);
} catch (std::exception const & ) {
return errFailed;
}
return errNone;
}
int prPipeClose(struct VMGlobals *g, int numArgsPushed)
{
PyrSlot *a;
PyrSlot *b;
PyrFile *pfile;
FILE *file;
pid_t pid;
a = g->sp - 1;
b = g->sp;
pfile = (PyrFile*)slotRawObject(a);
file = (FILE*)slotRawPtr(&pfile->fileptr);
if (file == NULL) return errNone;
pid = (pid_t) slotRawInt(b);
SetPtr(&pfile->fileptr, NULL);
int perr = sc_pclose(file, pid);
SetInt(a, perr);
if (perr == -1)
return errFailed;
return errNone;
}
EXPORT_C TStreamPos TDesBuf::DoSeekL(TMark aMark,TStreamLocation aLocation,TInt anOffset)
//
// Position the mark(s) indicated by aMark at anOffset from aLocation.
//
{
Consolidate();
TUint8* ptr=0;
switch (aLocation)
{
case EStreamBeginning:
ptr=Base()+anOffset;
break;
case EStreamMark:
ptr=Ptr(aMark)+anOffset;
break;
case EStreamEnd:
ptr=End(ERead)+anOffset;
break;
default:
Panic(EMemLocationInvalid);
break;
}
TInt r=KErrNone;
if (ptr>End(ERead))
{
ptr=End(ERead);
r=KErrEof;
}
else if (ptr<Base())
{
ptr=Base();
r=KErrEof;
}
//
SetPtr(aMark,ptr);
__LEAVE_IF_ERROR(r);
return TStreamPos(ptr-Base());
}
bool Window_UseSkillBase::Setup(
Game_AliceDollList* _pDollList,
Record_Item* _pItemRecord,
Record_AliceInfo* _pAliceInfo){
SetFrame(&g_wndSkins.skin[WNDSKIN_DOLLMANAGE], PRESETCOLORSET_BROWN);
if(!SetPtr(_pDollList, _pItemRecord, _pAliceInfo)){
return false;
}
// 一体を選択しての左のメニューは使用しない
SetMenuSize(1);
// アイテムマネージャ・スキルマネージャのセットアップ
SetupItemManager(true);
SetupSkillManager();
// 使用スキルマネージャのセットアップ
useSkillManager.Setup(_pDollList, _pAliceInfo);
// フェイズと人形の設定
phaze = WND_USESKILL_PHAZE_SKILLSELECT;
managingDollIndex = -1;
// リフレッシュ(クラスによって異なる)
// ここで、使用可能なスキルのインポートを行う。
ImportSkills();
return true;
}
int prNetAddr_Connect(VMGlobals *g, int numArgsPushed)
{
PyrSlot* netAddrSlot = g->sp;
PyrObject* netAddrObj = netAddrSlot->uo;
int err, port, addr;
err = slotIntVal(netAddrObj->slots + ivxNetAddr_PortID, &port);
if (err) return err;
err = slotIntVal(netAddrObj->slots + ivxNetAddr_Hostaddr, &addr);
if (err) return err;
struct sockaddr_in toaddr;
makeSockAddr(toaddr, addr, port);
int aSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (aSocket == -1) {
//post("\nCould not create socket\n");
return errFailed;
}
const int on = 1;
#ifdef SC_WIN32
if (setsockopt( aSocket, IPPROTO_TCP, TCP_NODELAY, (const char*)&on, sizeof(on)) != 0) {
#else
if (setsockopt( aSocket, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on)) != 0) {
#endif
//post("\nCould not setsockopt TCP_NODELAY\n");
#ifdef SC_WIN32
closesocket(aSocket);
#else
close(aSocket);
#endif
return errFailed;
};
if(connect(aSocket,(struct sockaddr*)&toaddr,sizeof(toaddr)) != 0)
{
//post("\nCould not connect socket\n");
#ifdef SC_WIN32
closesocket(aSocket);
#else
close(aSocket);
#endif
return errFailed;
}
SC_TcpClientPort *comPort = new SC_TcpClientPort(aSocket, netAddrTcpClientNotifyFunc, netAddrObj);
SetPtr(netAddrObj->slots + ivxNetAddr_Socket, comPort);
return errNone;
}
int prNetAddr_Disconnect(VMGlobals *g, int numArgsPushed);
int prNetAddr_Disconnect(VMGlobals *g, int numArgsPushed)
{
PyrSlot* netAddrSlot = g->sp;
PyrObject* netAddrObj = netAddrSlot->uo;
SC_TcpClientPort *comPort = (SC_TcpClientPort*)(netAddrObj->slots + ivxNetAddr_Socket)->uptr;
if (comPort) comPort->Close();
return errNone;
}
int prFileOpen(struct VMGlobals *g, int numArgsPushed)
{
PyrSlot *a, *b, *c;
char filename[PATH_MAX];
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(b)->size > PATH_MAX - 1) return errFailed;
if (slotRawObject(c)->size > 11) return errFailed;
pfile = (PyrFile*)slotRawObject(a);
memcpy(filename, slotRawString(b)->s, slotRawObject(b)->size);
filename[slotRawString(b)->size] = 0;
memcpy(mode, slotRawString(c)->s, slotRawObject(c)->size);
mode[slotRawString(c)->size] = 0;
#ifdef SC_WIN32
win32_ReplaceCharInString(filename,PATH_MAX,'/','\\');
if(strcmp(mode,"w") == 0)
strcpy(mode,"wb");
if(strcmp(mode,"r") == 0)
strcpy(mode,"rb");
#endif
//SC_WIN32
file = fopen(filename, mode);
if (file) {
SetPtr(&pfile->fileptr, file);
SetTrue(a);
} else {
#ifdef SC_WIN32
// check if directory exisits
// create a temporary file (somewhere) for a handle
// the file is deleted automatically when closed
if (sc_DirectoryExists(filename)) {
int err;
#ifdef _MSC_VER
err = tmpfile_s(&file);
if (!err) {
SetPtr(&pfile->fileptr, file);
SetTrue(a);
return errNone;
}
#elif defined(__MINGW32__)
file = tmpfile();
if (file) {
SetPtr(&pfile->fileptr, file);
SetTrue(a);
return errNone;
}
#else
#error compiler unsupported
#endif
}
#endif
SetNil(a);
SetFalse(a);
}
return errNone;
}
/////////////////////////////////////////////////////////////////////////////////////////
// DESC: Востановление с диска альтернативных ветвей растров
/// ARGS: rast - объект CSTR_rast
// in - указатель на FILE
// RETS: TRUE - успешно
// FALSE - ошибка
/////////////////////////////////////////////////////////////////////////////////////////
Bool32 CGRAPH_RestoreLoop(CSTR_rast rast, FILE *in)
{
int32_t count, lcount, rcount, curr_level = 1;
int32_t i, j;
intptr_t *ptr;
int32_t count_rast;
Bool32 flg = FALSE;
CSTR_rast rst = rast, curr_rst = rast;
CSTR_rast beg, end;
CSTR_attr attr = {0};
CSTR_rast_attr rast_attr = {0};
UniVersions uvers = {0};
CGRAPH_Data cstr = {0};
uchar *lp = NULL;
LoopData ld;
ALoop al;
al.n = 0;
al.loop = static_cast<intptr_t *>(malloc(sizeof(intptr_t) * memsize));
if(!al.loop)
return FALSE;
fread(&lcount, sizeof(lcount), 1, in);
for(i = 0, count = 0, rcount = 0; i < lcount; i++, count = 0)
{
fread(&ld, sizeof(ld), 1, in);
if(curr_level < ld.level)
flg = TRUE;
if(flg)
{
ptr = SetPtr(al.loop, rcount);
rst = (CSTR_rast)*ptr;
++rcount;
}
else
rst = rast;
//InsertRasterDown
while(rst)
{
if(count == ld.beg)
beg = rst;
if(count == ld.end)
end = rst;
++count;
rst = rst->next;
}
if(!beg || !end)
return FALSE;
if(!(curr_rst = CSTR_InsertRasterDown(beg, end)))
{
wLowRC = CGRAPH_ERR_PARAM;
return FALSE;
}
if(ld.loop)
{
for(j = 0; j < ld.loop; j++)
{
if(!AddLoop(&al, curr_rst))
{
wLowRC = CGRAPH_ERR_MEMORY;
return FALSE;
}
}
}
//Read Rasters
fread(&count_rast, sizeof(count_rast), 1, in);
fread(&attr, sizeof(CSTR_attr), 1, in);
//InsertRaster
for(j = 0; j < count_rast; j++)
{
fread(&cstr, sizeof(cstr), 1, in);
fread(&rast_attr, sizeof(CSTR_rast_attr), 1, in);
if(cstr.env)
{
if(cstr.uvers)
fread(&uvers, sizeof(uvers), 1, in);
if(cstr.size_linerep)
{
lp = (uchar *)malloc(cstr.size_linerep);
if(!lp)
{
wLowRC = CGRAPH_ERR_MEMORY;
return FALSE;
}
fread(lp, cstr.size_linerep, 1, in);
}
if(!(rst = CSTR_InsertRaster(curr_rst)))
{
wLowRC = CGRAPH_ERR_PARAM;
return FALSE;
}
if(!CSTR_SetAttr(rst, &rast_attr))
{
wLowRC = CGRAPH_ERR_PARAM;
return FALSE;
}
if(!CSTR_StoreComp(rst, (uchar*)((uchar*)lp), 1, cstr.scale))
{
wLowRC = CGRAPH_ERR_PARAM;
return FALSE;
}
if(cstr.uvers)
{
if(!CSTR_StoreCollectionUni(rst, &uvers))
{
wLowRC = CGRAPH_ERR_PARAM;
return FALSE;
}
}
if(lp)
free(lp);
}
else
{
if(cstr.uvers)
fread(&uvers, sizeof(uvers), 1, in);
if(!(rst = CSTR_InsertRaster(curr_rst)))
{
wLowRC = CGRAPH_ERR_PARAM;
return FALSE;
}
if(!CSTR_SetAttr(rst, &rast_attr))
{
wLowRC = CGRAPH_ERR_PARAM;
return FALSE;
}
if(cstr.uvers)
{
if(!CSTR_StoreCollectionUni(rst, &uvers))
{
wLowRC = CGRAPH_ERR_PARAM;
return FALSE;
}
}
}
}
}
free(al.loop);
return TRUE;
}
HOT void executeMethod(VMGlobals *g, PyrMethod *meth, long numArgsPushed)
{
PyrMethodRaw *methraw;
PyrFrame *frame;
PyrFrame *caller;
PyrSlot *pslot, *qslot;
PyrSlot *rslot;
PyrSlot *vars;
PyrObject *proto;
long i, m, mmax, numtemps, numargs;
#ifdef GC_SANITYCHECK
g->gc->SanityCheck();
CallStackSanity(g, "executeMethod");
#endif
#if DEBUGMETHODS
if (gTraceInterpreter) {
if (g->method) {
postfl(" %s:%s -> %s:%s\n",
slotRawSymbol(&slotRawClass(&g->method->ownerclass)->name)->name, slotRawSymbol(&g->method->name)->name,
slotRawSymbol(&slotRawClass(&meth->ownerclass)->name)->name, slotRawSymbol(&meth->name)->name);
} else {
postfl(" top -> %s:%s\n",
slotRawSymbol(&slotRawClass(&meth->ownerclass)->name)->name, slotRawSymbol(&meth->name)->name);
}
}
#endif
#if METHODMETER
if (gTraceInterpreter) {
slotRawInt(&meth->callMeter)++;
}
#endif
#if TAILCALLOPTIMIZE
int tailCall = g->tailCall;
if (tailCall) {
if (tailCall == 1) {
returnFromMethod(g);
} else {
returnFromBlock(g);
}
}
#endif
g->execMethod = 20;
proto = slotRawObject(&meth->prototypeFrame);
methraw = METHRAW(meth);
numtemps = methraw->numtemps;
numargs = methraw->numargs;
caller = g->frame;
//postfl("executeMethod allArgsPushed %d numKeyArgsPushed %d\n", allArgsPushed, numKeyArgsPushed);
frame = (PyrFrame*)g->gc->NewFrame(methraw->frameSize, 0, obj_slot, methraw->needsHeapContext);
vars = frame->vars - 1;
frame->classptr = class_frame;
frame->size = FRAMESIZE + proto->size;
SetObject(&frame->method, meth);
SetObject(&frame->homeContext, frame);
SetObject(&frame->context, frame);
if (caller) {
SetPtr(&caller->ip, g->ip);
SetObject(&frame->caller, caller);
} else {
SetInt(&frame->caller, 0);
}
SetPtr(&frame->ip, 0);
g->method = meth;
g->ip = slotRawInt8Array(&meth->code)->b - 1;
g->frame = frame;
g->block = (PyrBlock*)meth;
g->sp -= numArgsPushed;
qslot = g->sp;
pslot = vars;
if (numArgsPushed <= numargs) { /* not enough args pushed */
/* push all args to frame */
for (m=0,mmax=numArgsPushed; m<mmax; ++m) slotCopy(++pslot, ++qslot);
/* push default arg & var values */
pslot = vars + numArgsPushed;
qslot = proto->slots + numArgsPushed - 1;
for (m=0, mmax=numtemps - numArgsPushed; m<mmax; ++m) slotCopy(++pslot, ++qslot);
} else if (methraw->varargs) {
PyrObject *list;
PyrSlot *lslot;
/* push all normal args to frame */
for (m=0,mmax=numargs; m<mmax; ++m) slotCopy(++pslot, ++qslot);
/* push list */
i = numArgsPushed - numargs;
list = newPyrArray(g->gc, (int)i, 0, false);
list->size = (int)i;
rslot = pslot+1;
SetObject(rslot, list);
//SetObject(vars + numargs + 1, list);
/* put extra args into list */
lslot = (list->slots - 1);
// fixed and raw sizes are zero
for (m=0,mmax=i; m<mmax; ++m) slotCopy(++lslot, ++qslot);
if (methraw->numvars) {
/* push default keyword and var values */
pslot = vars + numargs + 1;
qslot = proto->slots + numargs;
for (m=0,mmax=methraw->numvars; m<mmax; ++m) slotCopy(++pslot, ++qslot);
}
} else {
/* push all args to frame */
for (m=0,mmax=numargs; m<mmax; ++m) slotCopy(++pslot, ++qslot);
if (methraw->numvars) {
/* push default keyword and var values */
pslot = vars + numargs;
qslot = proto->slots + numargs - 1;
for (m=0,mmax=methraw->numvars; m<mmax; ++m) slotCopy(++pslot, ++qslot);
}
}
slotCopy(&g->receiver, &vars[1]);
#ifdef GC_SANITYCHECK
g->gc->SanityCheck();
CallStackSanity(g, "<executeMethod");
#endif
}
/////////////////////////////////////////////////////////////////////////////////////////
// DESC: Получить число петлей и инициализировать Aloop
// ARGS: al - указатель на ALoop
// rast - растр
// RETS: TRUE - OK
// FALSE - ошибка
/////////////////////////////////////////////////////////////////////////////////////////
Bool32 CGRAPH_GetLoopCount(ALoop *al, CSTR_rast rast)
{
int32_t curr_level = 1;
int32_t i;
intptr_t *ptr;
CSTR_rast curr_rst;
CSTR_rast next_rst;
curr_rst = rast;
next_rst = rast;
al->n = 0;
al->loop = static_cast<intptr_t*> (malloc(sizeof(intptr_t) * memsize));
if(!al->loop)
{
wLowRC = CGRAPH_ERR_MEMORY;
return FALSE;
}
//get first part of loops
while(next_rst)
{
if(next_rst->next_down)
{
if(!AddLoop(al, curr_rst))
{
wLowRC = CGRAPH_ERR_MEMORY;
return FALSE;
}
if(!AddLoop(al, next_rst->next_down))
{
wLowRC = CGRAPH_ERR_MEMORY;
return FALSE;
}
if(!AddLevel(al, curr_level))
{
wLowRC = CGRAPH_ERR_MEMORY;
return FALSE;
}
}
next_rst = next_rst->next;
}
//get next parts of loops
for(i = 0; i < al->n; i++)
{
ptr = SetPtr(al->loop, ++i);
next_rst = (CSTR_rast)*(ptr);
ptr = SetPtr(al->loop, ++i);
curr_level = *(ptr);
curr_rst = next_rst;
++curr_level;
while(next_rst)
{
if(next_rst->next_down)
{
if(!AddLoop(al, curr_rst))
{
wLowRC = CGRAPH_ERR_MEMORY;
return FALSE;
}
if(!AddLoop(al, next_rst->next_down))
{
wLowRC = CGRAPH_ERR_MEMORY;
return FALSE;
}
if(!AddLevel(al, curr_level))
{
wLowRC = CGRAPH_ERR_MEMORY;
return FALSE;
}
}
next_rst = next_rst->next;
}
}
return TRUE;
}
