static void setaddr(int mode, unsigned char val) {
unsigned short ad,ad2;
switch(mode) {
case abs:
cycles+=2;
ad=getmem(pc-2);
ad|=256*getmem(pc-1);
setmem(ad,val);
return;
case absx:
cycles+=3;
ad=getmem(pc-2);
ad|=256*getmem(pc-1);
ad2=ad+x;
if ((ad2&0xff00)!=(ad&0xff00))
cycles--;
setmem(ad2,val);
return;
case zp:
cycles+=2;
ad=getmem(pc-1);
setmem(ad,val);
return;
case zpx:
cycles+=2;
ad=getmem(pc-1);
ad+=x;
setmem(ad&0xff,val);
return;
case acc:
a=val;
return;
}
}
void initvars(void)
/* Initializes various global variables */
{
leftcol = toprow = curcol = currow = lastcol = lastrow = 0;
setmem(colwidth, sizeof(colwidth), DEFAULTWIDTH);
setmem(cell, sizeof(cell), 0);
setmem(format, sizeof(format), DEFAULTFORMAT);
} /* initvars */
int main ()
{
union {
char buf [256];
void *pad;
} u;
int result = 0;
setmem (&u, sizeof u, 'x');
// check that a fundamental type is zeroed out on initialization
int i = int ();
if (i != 0)
result |= 1;
// check that a POD object is zeroed out on initialization
A a = A ();
if (!is_A_zero (a))
result |= 2;
// check that a POD object is zeroed out on initialization with operator new
A *pa = new (&u) A ();
if (!is_A_zero (*pa))
result |= 4;
setmem (&u, sizeof u, 'x');
S<A> *ps = new (&u) S<A>();
if (!is_SA_zero (*ps))
result |= 8;
setmem (&u, sizeof u, 'x');
X<int> *px = new (&u) X<int>();
if (!is_X_zero (*px))
result |= 16;
setmem (&u, sizeof u, 'x');
*px = X<int>();
if (!is_X_zero (*px))
result |= 32;
return result;
}
void load_warning_scr()
{
copymem((void *)0x78000, (void*)font_pc, 8192);
/* Clear out any leftover characters from previous BG. */
setmem((void*)BGMap(0), 0, 0x2000);
WA[31].head = WRLD_ON;
WA[31].gx = 0;
WA[31].gp = 0; //No parallax for now.
WA[31].gy = CENTER_Y(5)*8;
WA[31].mx = 0;
WA[31].mp = 0;
WA[31].my = 0;
WA[31].w = 384;
WA[31].h = (5*8 - 1);
WA[31].ovr = 0;
WA[31].param = 0;
WA[30].head = WRLD_END;
print_message(msg_warn[0], 0, CENTER_X(27), 0, 0);
print_message(msg_warn[1], 0, CENTER_X(23), 2, 0);
print_message(msg_warn[2], 0, CENTER_X(16), 4, 0);
}
//---------------------------------------------------------------------------
void TConsoleRunner::ReadFromPipe(vector<string>* answer, HWND parentHandle){
DWORD dwRead, dwWritten;
CHAR chBuf[4096];
// Close the write end of the pipe before reading from the
// read end of the pipe.
if (!CloseHandle(hChildStdoutWr)){
lastError = "Closing handle failed";
}
// Read output from the child process, and write to parent's STDOUT.
//if(!WriteFile(hChildStdinWr, "drowssap\r", 9, &dwWritten, NULL)){
// OutputDebugString("oops");
//}
while(true){
setmem(chBuf, 4096, 0);
if( !ReadFile( hChildStdoutRd, chBuf, 4096, &dwRead, NULL) || dwRead == 0){
break;
}
answer->push_back(chBuf);
if(parentHandle){
SendMessage(parentHandle, MSG_TO_STDOUT, answer->size() - 1, 0);
}
Application->ProcessMessages();
}
}
static void ClearStalled (PDEVICELIST pDevice, UCHAR endPoint)
{
RP_GENIOCTL rp;
USBClearStalled rb;
#ifdef DEBUG
dsPrint2 (DBG_DETAILED, "USBRESMGR: ClearStalled Device[%x], ep=%x\r\n", pDevice, endPoint);
#endif
rb.controllerId = pDevice->pDeviceInfo->ctrlID;
rb.deviceAddress = pDevice->pDeviceInfo->deviceAddress;
rb.endPointId = endPoint;
rb.clientIDCAddr = NULL; // no irq notification for this request
rb.clientDS = 0;
rb.irqSwitchValue = 0;
rb.requestData2 = 0;
rb.requestData3 = 0;
rb.category = USB_IDC_CATEGORY_CLASS;
rb.clearStalled = &pDevice->setupPack;
setmem ((PSZ)&rp, 0, sizeof(rp));
rp.rph.Cmd = CMDGenIOCTL;
rp.Category = USB_IDC_CATEGORY_USBD;
rp.Function = USB_IDC_FUNCTION_CLRSTALL;
rp.ParmPacket = (PVOID)&rb;
USBCallIDC (gpUSBDIDC, gdsUSBDIDC, (RP_GENIOCTL FAR *)&rp);
}
int YMODEMCLASS::CheckDataBlock0(void)
{
int rVal=FT_SUCCESS ;
char *path ;
path = new char[256] ;
if (Status)
{
lpStatus->writeName = TRUE ;
lstrcpy(lpStatus->filename, lpBuffer) ;
lpStatus->blocksize +=128 ;
lpStatus->blockno++ ;
lpStatus->UpdateStatusWindow() ;
if (lpStatus->transferStop) return FT_LOCALCANCEL ;
lpStatus->writeName = FALSE ;
}
if (lpBuffer[0]=='\0')
{
CommPutChar (oiConn, ACK) ;
if(Status)
DestroyWindow(lpStatus->hStatus) ;
return(FT_FILEEND);
}
sprintf (path, "%s\\%s", directory, lpBuffer) ;
if (!lpBuffer[lstrlen (lpBuffer)+1])
{
length = 0L;
moddate = 0L ;
}
else
{
sscanf(&lpBuffer[lstrlen(lpBuffer)+1], "%ld %lo", &length, &moddate) ;
}
OFSTRUCT of ;
if (hFile!=HFILE_ERROR)
{
CloseHandle (hFile) ;
hFile = HFILE_ERROR ;
}
if (hFile==HFILE_ERROR)
{
char *filename = CutFileName (path) ;
hFile = CreateFile (filename, &of, OF_CREATE) ;
}
if (hFile!=HFILE_ERROR)
{
rvDataCount = 0 ;
setmem(lpBuffer, maxblocksize, ' ') ;
CommPutChar (oiConn, ACK) ;
bLastSeq = bSeq ;
bSeq++ ;
dataBlock0 = FALSE ;
fltr_state = WAIT_SOH ;
}
else
rVal =FT_LOCALCANCEL ;
return rVal ;
}
void Draw_Box(int x, int y, int sizex, int sizey, char color) {
unsigned char far *linestart, far *lineend;
lineend=&screen[x+((y+sizey)<<6)+((y+sizey)<<8)];
for (linestart=&screen[x+(y<<6)+(y<<8)];
linestart<lineend; linestart+=WIDTH)
setmem(linestart, sizex, color);
}
void insertcol(int col)
/* Inserts a column */
{
int counter, row;
if (lastcol == MAXCOLS - 1)
{
for (counter = 0; counter <= lastrow; counter++)
deletecell(lastcol, counter, NOUPDATE);
printfreemem();
}
if (col != MAXCOLS - 1)
{
movmem(&cell[col][0], &cell[col + 1][0], MAXROWS * sizeof(CELLPTR) *
(MAXCOLS - col - 1));
movmem(&format[col][0], &format[col + 1][0], MAXROWS * (MAXCOLS - col - 1));
movmem(&colwidth[col], &colwidth[col + 1], MAXCOLS - col - 1);
}
setmem(&cell[col][0], MAXROWS * sizeof(CELLPTR), 0);
setmem(&format[col][0], MAXROWS, DEFAULTFORMAT);
colwidth[col] = DEFAULTWIDTH;
lastcol = MAXCOLS - 1;
setlastcol();
setrightcol();
if (curcol > rightcol)
{
rightcol++;
setleftcol();
}
for (counter = 0; counter <= lastcol; counter++)
{
for (row = 0; row <= lastrow; row++)
{
if ((cell[counter][row] != NULL) &&
(cell[counter][row]->attrib == FORMULA))
fixformula(counter, row, COLADD, col);
updateoflags(col, row, NOUPDATE);
}
}
while (col <= rightcol)
displaycol(col++, NOUPDATE);
changed = TRUE;
recalc();
} /* insertcol */
/*------------------------------------------------------------------------*
Name calloc - allocates main memory
Usage void *calloc(size_t nelem, size_t elsize);
Prototype in stdlib.h and alloc.h
Description calloc allocates a block like malloc, except the block is
of size nelem times elsize. The block is cleared to 0.
Return value calloc returns a pointer to the newly allocated block, or
NULL if not enough space exists for the new block or, the
requested size is equal to 0.
*-------------------------------------------------------------------------*/
void * _FARFUNC calloc(size_t nelem, size_t elsize)
{
unsigned long msize;
register char *cp;
msize = (unsigned long)nelem * elsize;
cp = (msize > 0xFFFF) ? NULL : malloc((unsigned)msize);
if (cp)
setmem(cp, (unsigned)msize, 0);
return(cp);
}
void colstring(int col, char *colstr)
/* Changes a column number to a string */
{
setmem(colstr, 3, 0);
if (col < 26)
colstr[0] = col + 'A';
else
{
colstr[0] = (col / 26) - 1 + 'A';
colstr[1] = (col % 26) + 'A';
}
} /* colstring */
void
ResetRegAlloc()
{
RegAlloc = RegReserved;
RegUsed = RegAlloc;
RegLocked= 0;
DataRegCache = RB_D0;
AddrRegCache = RB_A0;
TmpAry[0].ts_Size = 0;
TSIndex = 0;
TSMax = 0;
TryAgainFlag = 0;
setmem(Refs, sizeof(Refs), 0);
Refs[RB_A4] = 1; /* XXX hack */
Refs[RB_A5] = 1;
Refs[RB_A7] = 1;
setmem(Locked, sizeof(Locked), 0);
}
//------------------------------------------------------
Frame::Frame(int i,int j)
{
if( (i>0)&&(j>0)&&(i<MaxDim)&&(j<MaxDim) )
{
ImageData=new int[i*j];
setmem(ImageData,i*j*sizeof(int),0);
XDim=i;
YDim=j;
MaxValue=MeanValue=MinValue=0;
return;
};
Frame();
};
void writef(int col, int row, int color, int width, va_list arg_list, ...)
/* Prints a string in video memory at a selected location in a color */
{
va_list arg_ptr;
char *format;
char output[81];
int len;
va_start(arg_ptr, arg_list);
format = arg_list;
vsprintf(output, format, arg_ptr);
output[width] = 0;
if ((len = strlen(output)) < width)
setmem(&output[len], width - len, ' ');
setcolor(color);
gotoxy(col, row);
cprintf(output);
} /* writef */
int YMODEMCLASS::CheckDataBlock (void)
{
BYTE hiCRC ,loCRC ;
int bCRC ;
BYTE checksum ;
BOOL checkOK=TRUE ;
int rVal = FT_SUCCESS ;
if (fCRC)
{
hiCRC = CommGetChar (oiConn) ;
loCRC = CommGetChar (oiConn) ;
bCRC = CalcCRC16 (lpBuffer, maxblocksize) ;
if (hiCRC!=HIBYTE(bCRC)||loCRC!=LOBYTE(bCRC))
checkOK = FALSE ;
}
else
{
checksum = CommGetChar (oiConn) ;
if(checksum!=CheckSum (lpBuffer))
checkOK = FALSE ;
}
if (checkOK)
{
if (dataBlock0)
rVal = CheckDataBlock0() ;
else
{
fltr_state = WAIT_SOH ;
WriteToFile () ;
}
}
else
{
rvDataCount = 0 ;
setmem(lpBuffer, maxblocksize, ' ') ;
CommPutChar (oiConn, NAK) ;
fltr_state = WAIT_SOH ;
}
return (rVal) ;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::UpDown2Click(TObject *Sender, TUDBtnType Button)
{
setmem(ANodeBuffer, sizeof(ANodeBuffer), 0);
Series1->Clear();
double PushValue, t0 = 1e-5;
double SinusFreq = 4323.16;
int ReliazationLength = 45;
for ( double z = 0; z < t0*ReliazationLength; z = z + t0 )
{
PushValue = sin(2.0 * M_PI * SinusFreq * z + UpDown2->Position*M_PI / 180.0);
PushValue += 0.1 * sin(2.0 * M_PI * SinusFreq*2.5 * z + UpDown2->Position*M_PI / 180.0);
for ( int i = 63; i > 0; i-- ) ANodeBuffer[i] = ANodeBuffer[i-1];
ANodeBuffer[0] = PushValue;
}
Series1->AddArray(ANodeBuffer, ReliazationLength);
// ------------------------
UpDown1Click(NULL, btNext);
}
static BOOL CheckHCDDriversLoaded( PSZ cmdLine, USHORT start, USHORT end )
{
PSZ drvNameChar=cmdLine+start;
BOOL loaded = FALSE; //LR0904 was = TRUE
USHORT charIndex=0;
CHAR nChar;
gHCDDriverName[sizeof(gHCDDriverName)-1]=0;
if (*(cmdLine+start)=='(' && end>0 && *(cmdLine+end-1)==')')
{ // ignore enclosing braces
start++; end--; end--;
}
for (;start<=end; start++)
{
nChar=*(cmdLine+start);
if (nChar!=',' && nChar && nChar!=' ')
{ // fill in driver's name separated by ','
if (charIndex<sizeof(gHCDDriverName)-1)
{
if (!charIndex)
setmem(gHCDDriverName,' ',sizeof(gHCDDriverName)-1);
gHCDDriverName[charIndex]=nChar;
charIndex++;
}
}
if (nChar==',' || start==end) // process name when separator reached or on last character
{
charIndex=0;
// check if driver loaded
if (!DevHelp_AttachDD (gHCDDriverName, (NPBYTE)&gDDTable)) //LR0904 ! added
{
loaded = TRUE; //LR0904 was = FALSE
break;
}
}
}
return (loaded);
}
/*
* push -- push the given word on the given stack
*
* sp -- stack pointer register to use. Can be any of the eight
* general purpose registers.
* word -- the word to push on the stack
*/
static void push(size_t sp, size_t word)
{
setreg(sp, getreg(sp)+1);
setmem(getreg(sp), word);
}
/*
* simulate -- execute the program one CPU instruction at a time until HALT
*/
void simulate(void)
{
struct insn *insn;
size_t reg;
ssize_t tmp;
/* Before starting to run the program, establish a stack */
setreg(FP, memsize ? (memsize-1) : 0); /* initialize frame pointer */
setreg(SP, memsize); /* initialize stack pointer */
addmem(64); /* reserve memory for the stack at end of address space */
/* Each iteration of this loop executes one instruction */
while(!halted)
{
/* Fetch the instruction word */
ir = getmem(pc);
if(verbose)
{
printf("Executing ");
disasm(mem, pc, 1);
}
pc++;
/* Decode the instruction word */
insn = decode(ir);
reg = insn->reg;
tmp = (ssize_t)(int16_t)insn->imm;
if(insn->idxreg) tmp += (ssize_t)getreg(insn->idxreg);
tr = (size_t)tmp;
switch(insn->mode)
{
case 0: break;
case 1: tr = getmem(tr); break;
case 2: tr = getmem(getmem(tr)); break;
}
/* Execute the instruction */
switch(insn->opcode)
{
case 0x00: /*NOP*/
break;
case 0x01: /*STORE*/
setmem(tr, getreg(reg));
break;
case 0x02: /*LOAD*/
setreg(reg, tr);
break;
case 0x03: /*IN*/
if((tr >= COUNTOF(intab)) || !intab[tr]) die("no such input device");
setreg(reg, intab[tr]());
break;
case 0x04: /*OUT*/
if((tr >= COUNTOF(outtab)) || !outtab[tr]) die("no such output device");
outtab[tr](getreg(reg));
break;
case 0x11: setreg(reg, getreg(reg) + tr); break; /*ADD*/
case 0x12: setreg(reg, getreg(reg) - tr); break; /*SUB*/
case 0x13: setreg(reg, getreg(reg) * tr); break; /*MUL*/
case 0x14: setreg(reg, getreg(reg) / tr); break; /*DIV*/
case 0x15: setreg(reg, getreg(reg) % tr); break; /*MOD*/
case 0x16: setreg(reg, getreg(reg) & tr); break; /*AND*/
case 0x17: setreg(reg, getreg(reg) | tr); break; /*OR*/
case 0x18: setreg(reg, getreg(reg) ^ tr); break; /*XOR*/
case 0x19: setreg(reg, getreg(reg) << tr); break; /*SHL*/
case 0x1A: setreg(reg, size_shr(getreg(reg), tr)); break; /*SHR*/
case 0x1B: setreg(reg, size_sar(getreg(reg), tr)); break; /*SHRA*/
case 0x1F: compare(getreg(reg), tr); break; /*COMP*/
case 0x20: pc=tr; break; /*JUMP*/
case 0x21: if((ssize_t)getreg(reg) < 0) pc=tr; break; /*JNEG*/
case 0x22: if((ssize_t)getreg(reg) == 0) pc=tr; break; /*JZER*/
case 0x23: if((ssize_t)getreg(reg) > 0) pc=tr; break; /*JPOS*/
case 0x24: if((ssize_t)getreg(reg) >= 0) pc=tr; break; /*JNNEG*/
case 0x25: if((ssize_t)getreg(reg) != 0) pc=tr; break; /*JNZER*/
case 0x26: if((ssize_t)getreg(reg) <= 0) pc=tr; break; /*JNPOS*/
case 0x27: if(getsrbit(SR_L)) pc=tr; break; /*JLES*/
case 0x28: if(getsrbit(SR_E)) pc=tr; break; /*JEQU*/
case 0x29: if(getsrbit(SR_G)) pc=tr; break; /*JGRE*/
case 0x2A: if(!getsrbit(SR_L)) pc=tr; break; /*JNLES*/
case 0x2B: if(!getsrbit(SR_E)) pc=tr; break; /*JNEQU*/
case 0x2C: if(!getsrbit(SR_G)) pc=tr; break; /*JNGRE*/
case 0x31: /*CALL*/
push(reg, pc);
push(reg, getreg(FP));
setreg(FP, getreg(SP));
pc=tr;
break;
case 0x32: /*EXIT*/
setreg(FP, pop(reg));
pc = pop(reg);
for(; tr; tr--) pop(reg);
break;
case 0x33: /*PUSH*/
push(reg, tr);
break;
case 0x34: /*POP*/
setreg(insn->idxreg, pop(reg));
break;
case 0x35: /*PUSHR*/
push(reg, getreg(0));
push(reg, getreg(1));
push(reg, getreg(2));
push(reg, getreg(3));
push(reg, getreg(4));
push(reg, getreg(5));
break;
case 0x36: /*POPR*/
setreg(5, pop(reg));
setreg(4, pop(reg));
setreg(3, pop(reg));
setreg(2, pop(reg));
setreg(1, pop(reg));
setreg(0, pop(reg));
break;
case 0x70: /*SVC*/
if((tr >= COUNTOF(svctab)) || !svctab[tr]) die("no such supervisor call");
svctab[tr](reg);
break;
default:
die("bad instruction");
}
}
}
static void svc_read(size_t sp)
{
setmem(pop(sp), input());
}
static inline void push(unsigned char val) {
setmem(0x100+s,val);
if (s) s--;
}
//---------------------------------------------------------------------------
void TMainForm::ListResults()
{
AnsiString FileName=ExtractFileName(FName),OutFile;
FileName=FileName.SubString(1,FileName.Length()-4);
AnsiString DirName=ExtractFilePath(FName)+FileName;
CreateDir(DirName);
SetCurrentDir(DirName);
fstream file;
int NMols,NFrames=0,i,j,n,x,y;
float *MolIntegrInt,tmp;
OutFile=DirName+"\\Kinetics.txt";
file.open(OutFile.c_str(),ios::out);
for(n=0;n<Results.GetN() && !Results[n];n++){};
int StartFrame=n;
if(Pars.UseExProfile)
{ //deleting the molecules outside Pars.Cutoff*ExFrame.GetMax() area;
for(i=0;i<Results[n]->Count;i++)
{
x=Results[StartFrame]->Mol(i).x;
y=Results[StartFrame]->Mol(i).y;
if(ExFrame[y][x]<Pars.CutOff*ExFrame.GetMax())
for(j=0;j<Results.GetN();j++) if(Results[j]) Results[j]->Delete(i);
}
}
NMols=Results[StartFrame]->Count; //the first processed frame gives the number of molecules
file<<"Frame\t";
for(i=0;i<NMols;i++) file<<"Mol"<<i+1<<"\t";//kinetics file header
file<<endl;
MolIntegrInt=new float[NMols];
setmem(MolIntegrInt,NMols*sizeof(float),0);//starting integral values are zeros
for(;n<Results.GetN() && Results[n];n++)//printing kinetics file and counting aver.int.
{
NFrames++; //counting actual number of frames
file<<n+1<<"\t";
for(i=0;i<NMols;i++)
{
x=Results[StartFrame]->Mol(i).x;
y=Results[StartFrame]->Mol(i).y;
tmp=Results[n]->Mol(i).I;
if(Pars.Normalize) tmp*=(float)ExFrame.GetMax()/ExFrame[y][x];
MolIntegrInt[i]+=tmp; //integral intensity of each molecule
file<<floor(tmp)<<"\t";
}
file<<endl;
}
file.close();
OutFile=DirName+"\\"+FileName+"_coor.txt";
file.open(OutFile.c_str(),ios::out);
file<<"MolNum\tX\tY\tIaver";
if(Pars.UseExProfile) file<<"\tIex"; file<<endl; //coordinate file header
for(i=0;i<NMols;i++)
{
x=Results[StartFrame]->Mol(i).x;
y=Results[StartFrame]->Mol(i).y;
file<<i+1<<"\t"<<x+1<<"\t"<<y+1<<"\t"<<floor(MolIntegrInt[i]/NFrames); //aver. int.
if(Pars.UseExProfile) file<<"\t"<<(float)ExFrame[y][x]/ExFrame.GetMax(); file<<endl;
}
file.close();
//ImproveSignals(ExSignals,NFrames);
//ImproveSignals(EmSignals,NFrames);
OutFile=DirName+"\\"+"SignalsEx.txt";
file.open(OutFile.c_str(),ios::out);
for(i=0;i<NFrames;i++) file<<ExSignals[i]<<endl;
file.close();
OutFile=DirName+"\\"+"SignalsEm.txt";
file.open(OutFile.c_str(),ios::out);
for(i=0;i<NFrames;i++) file<<EmSignals[i]<<endl;
file.close();
delete[] MolIntegrInt;
}
void IO_GO(int sig){
syslog(LOG_ERR, "SIG IO SIG IO!!!!!!"); //Log it
mainfd = open_port();
struct sockaddr_in clientName = { 0 };
int BuffCount; // Got Count
char Buff[1024]; //Buffer size
bzero(Buff,sizeof(Buff)); //Zero out the buffer
int simpleChildSocket = 0;
int clientNameLength = sizeof(clientName);
int flag=0;
char endL[3];
char TempBuff[256];
int TempCount;
int returnstatus;
bzero(endL,sizeof(endL));
//transbridgeon(mainfd);
sprintf(endL,"%c%c",end,0x82);
simpleChildSocket = accept(simpleSocket,(struct sockaddr *)&clientName, &clientNameLength);
if (simpleChildSocket == -1) {
syslog(LOG_ERR, "Cannot accept connections!\n");
close(simpleSocket);
exit(1);
}
BuffCount=read(simpleChildSocket, Buff, 3);
TempCount=sprintf(TempBuff,"%d",BuffCount);
syslog(LOG_WARNING, "I read %d : %s",BuffCount,Buff);
//trying a switch case to select the begining mode of the sign protocoll
switch(Buff[0]){
case 'A':// Sign Type, Sign Addr (last bit)
startc(mainfd,Buff[1],Buff[2]);
TempCount=sprintf(TempBuff,"CASE A");
write(simpleChildSocket, TempBuff, strlen(TempBuff) );
bzero(Buff,sizeof(Buff));
break;
case 'B': //simple mode
starttext(mainfd,'Z','0','A');
TempCount=sprintf(TempBuff," CASE B");
write(simpleChildSocket, TempBuff, strlen(TempBuff));
bzero(Buff,sizeof(Buff));
break;
case 'C': //set 2 line mem
TempCount=sprintf(TempBuff,"CASE C");
write(simpleChildSocket, TempBuff, strlen(TempBuff));
syslog(LOG_ERR, "CASE C Buff1=%c",Buff[1]);
setmem(mainfd,Buff[1]);
bzero(Buff,sizeof(Buff));
flag =1; // skip loop
break;
case 'D': //Single line set memory
TempCount=sprintf(TempBuff,"CASE D");
write(simpleChildSocket, TempBuff, strlen(TempBuff));
syslog(LOG_ERR, "CASE D"); //Log it
slsetmem(mainfd,Buff[1]);
bzero(Buff,sizeof(Buff));
syslog(LOG_ERR, "End of Case D"); //Log it
flag =1;
break;
case 'P':
plotit();
flag=1;
break;
case 'X':
TempCount=sprintf(TempBuff,"CASE X");
write(simpleChildSocket, TempBuff, strlen(TempBuff));
bzero(Buff,sizeof(Buff));
break;
}
while(flag != 1){
BuffCount=read(simpleChildSocket, Buff, sizeof(Buff));
if(DEBUG == 1)
syslog(LOG_WARNING, "I read %d : %s",BuffCount,Buff);
if(endsearch(Buff)==1 )
{
flag=1;
}
if(BuffCount == 0){
flag =1;
}
/* handle the new connection request */
/* write out our message to the client */
write(mainfd,Buff,strlen(Buff));
bzero(Buff,sizeof(Buff));
/* OLD CODE SNIPPIT
write(simpleChildSocket, ACKMESSAGE, strlen(ACKMESSAGE));
close(simpleChildSocket);
transbridgeon(mainfd);
write(mainfd,Buff,strlen(Buff));
transbridgeoff(mainfd);
*/
}
//transbridgeoff(mainfd);
write(simpleChildSocket, ACKMESSAGE, strlen(ACKMESSAGE));
close(simpleChildSocket);
close(mainfd);
flag = 0;
usleep(250);
}
/*
Initialization of adventure play variables
*/
void initplay(void) {
turns = 0;
/* initialize location status array */
setmem(cond, (sizeof(int)) * MAXLOC, 0);
scanint(&cond[1], "5,1,5,5,1,1,5,17,1,1,");
scanint(&cond[13], "32,0,0,2,0,0,64,2,");
scanint(&cond[21], "2,2,0,6,0,2,");
scanint(&cond[31], "2,2,0,0,0,0,0,4,0,2,");
scanint(&cond[42], "128,128,128,128,136,136,136,128,128,");
scanint(&cond[51], "128,128,136,128,136,0,8,0,2,");
scanint(&cond[79], "2,128,128,136,0,0,8,136,128,0,2,2,");
scanint(&cond[95], "4,0,0,0,0,1,");
scanint(&cond[113], "4,0,1,1,");
scanint(&cond[122], "8,8,8,8,8,8,8,8,8,");
/* initialize object locations */
setmem(place, (sizeof(int)) * MAXOBJ, 0);
scanint(&place[1], "3,3,8,10,11,0,14,13,94,96,");
scanint(&place[11], "19,17,101,103,0,106,0,0,3,3,");
scanint(&place[23], "109,25,23,111,35,0,97,");
scanint(&place[31], "119,117,117,0,130,0,126,140,0,96,");
scanint(&place[50], "18,27,28,29,30,");
scanint(&place[56], "92,95,97,100,101,0,119,127,130,");
/* initialize second (fixed) locations */
setmem(fixed, (sizeof(int)) * MAXOBJ, 0);
scanint(&fixed[3], "9,0,0,0,15,0,-1,");
scanint(&fixed[11], "-1,27,-1,0,0,0,-1,");
scanint(&fixed[23], "-1,-1,67,-1,110,0,-1,-1,");
scanint(&fixed[31], "121,122,122,0,-1,-1,-1,-1,0,-1,");
scanint(&fixed[62], "121,-1,");
/* initialize default verb messages */
scanint(actmsg, "0,24,29,0,33,0,33,38,38,42,14,");
scanint(&actmsg[11], "43,110,29,110,73,75,29,13,59,59,");
scanint(&actmsg[21], "174,109,67,13,147,155,195,146,110,13,13,");
/* initialize various flags and other variables */
setmem(visited, (sizeof(int)) * MAXLOC, 0);
setmem(prop, (sizeof(int)) * MAXOBJ, 0);
setmem(&prop[50], (sizeof(int)) * (MAXOBJ - 50), 0xff);
wzdark = closed = closing = holding = detail = 0;
limit = 100;
tally = 15;
tally2 = 0;
newloc = 3;
loc = oldloc = oldloc2 = 1;
knfloc = 0;
chloc = 114;
chloc2 = 140;
/* dloc[DWARFMAX-1] = chloc */
scanint(dloc, "0,19,27,33,44,64,114,");
scanint(odloc, "0,0,0,0,0,0,0,");
dkill = 0;
scanint(dseen, "0,0,0,0,0,0,0,");
clock1 = 30;
clock2 = 50;
panic = 0;
bonus = 0;
numdie = 0;
daltloc = 18;
lmwarn = 0;
foobar = 0;
dflag = 0;
gaveup = 0;
saveflg = 0;
}
t_jit_err jit_demultiplex_matrix_calc(t_jit_demultiplex *x, void *inputs, void *outputs)
{
t_jit_err err=JIT_ERR_NONE;
t_jit_matrix_info in_minfo,out_minfo,out2_minfo;
long i;
t_matrix_conv_info conv, conv2;
char demultiplexdim = CLAMP(x->demultiplexdim,0,JIT_MATRIX_MAX_DIMCOUNT);
t_jit_matrix_info *a_minfo,*b_minfo;
void *a_matrix,*b_matrix;
long tmpsize, tmp, mod, a_start, b_start, c_start, plexsize;
long offset, offset2;
long scan_a = x->scan_a;
long scan_b = x->scan_b;
void *in_matrix,*out_matrix,*out2_matrix;
in_matrix = jit_object_method(inputs,_jit_sym_getindex,0);
out_matrix = jit_object_method(outputs,_jit_sym_getindex,0);
out2_matrix = jit_object_method(outputs,_jit_sym_getindex,1);
if (x && in_matrix && out_matrix && out2_matrix) {
jit_object_method(in_matrix,_jit_sym_getinfo,&in_minfo);
jit_object_method(out_matrix,_jit_sym_getinfo,&out_minfo);
jit_object_method(out2_matrix,_jit_sym_getinfo,&out2_minfo);
if (jit_demultiplex_calc_out_matrix(x, &in_minfo, in_matrix, &out_minfo, out_matrix, &out2_minfo, out2_matrix)) {
err=JIT_ERR_GENERIC;
goto out;
}
//double check
//compatible types?
if ((in_minfo.type != out2_minfo.type) && (in_minfo.type != out_minfo.type)) {
err=JIT_ERR_MISMATCH_TYPE;
goto out;
}
//allow any planes, will simply wrap. i think that's okay - jkc
setmem(&conv,sizeof(t_matrix_conv_info),0);
setmem(&conv2,sizeof(t_matrix_conv_info),0);
for (i=0;i<JIT_MATRIX_MAX_PLANECOUNT;i++) {
conv.planemap[i] = i;
conv2.planemap[i] = i;
}
conv.flags = conv2.flags = JIT_MATRIX_CONVERT_SRCDIM | JIT_MATRIX_CONVERT_DSTDIM;
// just for ease and later expandability
a_minfo = &out_minfo;
a_matrix = out_matrix;
b_minfo = &out2_minfo;
b_matrix = out2_matrix;
// need to set these first, and only copy in the while tmp-- loop
for (i = 0; i < in_minfo.dimcount; i++) {
conv.srcdimstart[i] = conv2.srcdimstart[i] = 0;
conv.srcdimend[i] = conv2.srcdimend[i] = in_minfo.dim[i] - 1;
conv.dstdimstart[i] = conv2.dstdimstart[i] = 0;
conv.dstdimend[i] = conv2.dstdimend[i] = in_minfo.dim[i] - 1;
}
i = demultiplexdim;
CLIP(scan_a, 0, in_minfo.dim[i]);
CLIP(scan_b, 0, in_minfo.dim[i]);
plexsize = CLAMP(scan_a + scan_b, 0, in_minfo.dim[i]);
tmpsize = in_minfo.dim[i];
tmp = (tmpsize / plexsize);
mod = (tmpsize % plexsize);
a_start = 0;
b_start = 0;
c_start = 0;
if (scan_b == 0) {
conv.srcdimstart[i] = CLAMP(a_start, 0, in_minfo.dim[i] - 1);
conv.srcdimend[i] = CLAMP(a_start + (scan_a - 1), 0, in_minfo.dim[i] - 1);
conv.dstdimstart[i] = CLAMP(b_start, 0, out_minfo.dim[i] - 1);
conv.dstdimend[i] = CLAMP(b_start + (scan_a - 1), 0, out_minfo.dim[i] - 1);
jit_object_method(out_matrix, _jit_sym_frommatrix, in_matrix, &conv);
goto out;
}
else if (scan_a == 0) {
conv2.srcdimstart[i] = CLAMP(a_start, 0, in_minfo.dim[i] - 1);
conv2.srcdimend[i] = CLAMP(a_start + (scan_b - 1), 0, in_minfo.dim[i] - 1);
conv2.dstdimstart[i] = CLAMP(c_start, 0, out2_minfo.dim[i] - 1);
conv2.dstdimend[i] = CLAMP(c_start + (scan_b - 1), 0, out2_minfo.dim[i] - 1);
jit_object_method(out2_matrix, _jit_sym_frommatrix, in_matrix, &conv2);
goto out;
}
else while (tmp--) {
conv.srcdimstart[i] = CLAMP(a_start, 0, in_minfo.dim[i] - 1);
conv.srcdimend[i] = CLAMP(a_start + (scan_a - 1), 0, in_minfo.dim[i] - 1);
conv.dstdimstart[i] = CLAMP(b_start, 0, out_minfo.dim[i] - 1);
conv.dstdimend[i] = CLAMP(b_start + (scan_a - 1), 0, out_minfo.dim[i] - 1);
a_start += scan_a;
b_start += scan_a;
conv2.srcdimstart[i] = CLAMP(a_start, 0, in_minfo.dim[i] - 1);
conv2.srcdimend[i] = CLAMP(a_start + (scan_b - 1), 0, in_minfo.dim[i] - 1);
conv2.dstdimstart[i] = CLAMP(c_start, 0, out2_minfo.dim[i] - 1);
conv2.dstdimend[i] = CLAMP(c_start + (scan_b - 1), 0, out2_minfo.dim[i] - 1);
a_start += scan_b;
c_start += scan_b;
jit_object_method(out_matrix, _jit_sym_frommatrix, in_matrix, &conv);
jit_object_method(out2_matrix, _jit_sym_frommatrix, in_matrix, &conv2);
}
if (mod) {
offset = (mod < scan_a) ? mod : scan_a;
offset2 = (mod - scan_a <= 0) ? 0 : mod - scan_a;
conv.srcdimstart[i] = CLAMP(a_start, 0, in_minfo.dim[i] - 1);
conv.srcdimend[i] = CLAMP(a_start + (offset - 1), 0, in_minfo.dim[i] - 1);
conv.dstdimstart[i] = CLAMP(b_start, 0, out_minfo.dim[i] - 1);
conv.dstdimend[i] = CLAMP(b_start + (offset - 1), 0, out_minfo.dim[i] - 1);
a_start += offset;
b_start += offset;
if (a_start > in_minfo.dim[i] - 1) {
jit_object_method(out_matrix, _jit_sym_frommatrix, in_matrix, &conv);
goto out;
}
conv2.srcdimstart[i] = CLAMP(a_start, 0, in_minfo.dim[i] - 1);
conv2.srcdimend[i] = CLAMP(a_start + (offset2 - 1), 0, in_minfo.dim[i] - 1);
conv2.dstdimstart[i] = CLAMP(c_start, 0, out2_minfo.dim[i] - 1);
conv2.dstdimend[i] = CLAMP(c_start + (offset2 - 1), 0, out2_minfo.dim[i] - 1);
jit_object_method(out_matrix, _jit_sym_frommatrix, in_matrix, &conv);
jit_object_method(out2_matrix, _jit_sym_frommatrix, in_matrix, &conv2);
}
}
else return JIT_ERR_INVALID_PTR;
out:
return err;
}
//------------------------------------------------------
void Frame::Reset()
{
setmem(ImageData,XDim*YDim*sizeof(int),0);
MaxValue=MeanValue=MinValue=0;
};
static void putaddr(int mode, unsigned char val) {
unsigned short ad,ad2;
switch(mode) {
case abs:
cycles+=4;
ad=getmem(pc++);
ad|=getmem(pc++)<<8;
setmem(ad,val);
return;
case absx:
cycles+=4;
ad=getmem(pc++);
ad|=getmem(pc++)<<8;
ad2=ad+x;
setmem(ad2,val);
return;
case absy:
cycles+=4;
ad=getmem(pc++);
ad|=getmem(pc++)<<8;
ad2=ad+y;
if ((ad2&0xff00)!=(ad&0xff00)) cycles++;
setmem(ad2,val);
return;
case zp:
cycles+=3;
ad=getmem(pc++);
setmem(ad,val);
return;
case zpx:
cycles+=4;
ad=getmem(pc++);
ad+=x;
setmem(ad&0xff,val);
return;
case zpy:
cycles+=4;
ad=getmem(pc++);
ad+=y;
setmem(ad&0xff,val);
return;
case indx:
cycles+=6;
ad=getmem(pc++);
ad+=x;
ad2=getmem(ad&0xff);
ad++;
ad2|=getmem(ad&0xff)<<8;
setmem(ad2,val);
return;
case indy:
cycles+=5;
ad=getmem(pc++);
ad2=getmem(ad);
ad2|=getmem((ad+1)&0xff)<<8;
ad=ad2+y;
setmem(ad,val);
return;
case acc:
cycles+=2;
a=val;
return;
}
}
BOOL fedit(char *filename)
{
FILE *fp;
char *buf;
unsigned int lim; /* can't edit more then a segment anyway */
long filesize;
int rc = FALSE;
int err;
char path[64];
getcwd(path,64);
err = errno = 0;
/* set the message entry flags and buffer */
clearmsgbuf();
setmem(msgBuf, sizeof(struct msgB), 0);
mailFlag = FALSE;
oldFlag = FALSE;
limitFlag = FALSE;
linkMess = FALSE;
if (loggedIn)
strcpy(msgBuf->mbauth,logBuf.lbname);
/* try to edit an existing file */
if (filexists(filename)) {
fp = fopen(filename,"rt");
if (fp) {
filesize = filelength(fileno(fp));
if ((unsigned int) (filesize + (long) cfg.maxtext) > UINT_MAX) {
err = -2;
cPrintf("\nFile too long\n");
} else {
lim = cfg.maxtext + (int) filesize;
buf = calloc(1,lim);
if (buf) {
errno = 0;
if (!fread(buf,1,lim,fp)) {
cPrintf("\nFile read error\n");
err = errno;
}
if (fclose(fp) && !err) {/* we need to 'recreate' later */
cPrintf("\nFile close error\n");
err = errno;
}
if (!err)
mFormat(buf); /* display the file */
oldFlag = TRUE;
}
}
} else {
lim = cfg.maxtext;
buf = calloc(1,lim);
oldFlag = FALSE;
}
}
if (buf && !err && editBuf(buf,lim)) {
changedir(path); /* because silly edit routines loose path */
if (!strblank(buf)) {
rc = TRUE;
lim = strlen(buf);
errno = 0; /* because silly video routines set it */
fp = fopen(filename,"wt");
if (!fp && !err) {
cPrintf("\nFile open error 2\n");
err = errno;
}
if (fp) {
/* because silly DOS doesn't 'error' on disk full */
if(!fwrite(buf,1,lim,fp) && !errno) {
cPrintf("\nFile write error\n");
err = -1;
}
errno = 0;
if (!fclose(fp)&& !err) {
cPrintf("\nFile close error 2\n");
err = errno;
}
}
} else { /* we won't save empty files */
rc = FALSE;
}
}
if (!buf) { /* out of memory condition */
mtPrintf(TERM_BOLD," \n Out of memory editing file %s.\n",filename);
rc = FALSE;
} else {
switch (err) {
case 0: /* no error */
break;
case -1: /* disk full condition */
mtPrintf(TERM_BOLD,
" \n Disk full saving %s, file truncated.\n",filename);
rc = FALSE;
break;
case -2: /* file >64k condition */
mtPrintf(TERM_BOLD,
" \n File %s is too large to edit.\n",filename);
rc = FALSE;
break;
default: /* DOS error condition */
mtPrintf(TERM_BOLD, " \n DOS error '%s' editing %s: \n",
strerror(err),filename);
rc = FALSE;
break;
}
}
if (buf) {
free(buf);
buf = NULL;
}
return rc;
}
/************************ END OF SPECIFICATIONS ***********************/
void USBInit( RPH FAR *pRP )
{
PRPINITOUT pRPO; /* output request packet far pointer */
PRPINITIN pRPI; /* input request packet far pointer */
UINT ctrlID;
KeyData keyData[3]={"V",CFSTR_TYPE_DEC,0,0,
"REQ:",CFSTR_TYPE_STRING,0,0,
"I13",CFSTR_TYPE_DEC,0,0}; // 31/05/1999 MB
PSZ cmdLine;
ULONG cmdRStatus, errColumn;
USHORT cmdRc;
#ifdef DEBUG
dsPrint(DBG_HLVLFLOW, "USBD: USBInit started\r\n");
#endif
pRP->Status = STATUS_DONE;
if (ghDriver) // initialization already passed
return;
pRPI = (PRPINITIN) pRP;
pRPO = (PRPINITOUT) pRP;
Device_Help = ((PRPINITIN)pRP)->DevHlpEP; /* save devhlp entry point */
// process CONFIG.SYS BASEDEV= line parameters
cmdLine=(PSZ) MAKEP( SELECTOROF(pRPI->InitArgs),
OFFSETOF(((PDDD_PARM_LIST)pRPI->InitArgs)->cmd_line_args) );
cmdRStatus=ProcessConfigString(cmdLine, sizeof(keyData)/sizeof(keyData[0]), (KeyData FAR *)&keyData);
cmdRc=LOUSHORT(cmdRStatus); errColumn=(ULONG)HIUSHORT(cmdRStatus);
switch (cmdRc) // set cmd line processing errors
{
case CFSTR_UNKWN_KEYS:
SetLongValue( gVMessages[INIT_MESSAGE_UNKNOWNKWD], errColumn );
gMessageCount=AddToMsgArray( gMessageIDs, INIT_MESSAGE_UNKNOWNKWD, gMessageCount, MAX_INIT_MESSAGE_COUNT );
break;
case CFSTR_CONVERR:
SetLongValue( gVMessages[INIT_MESSAGE_INVNUMERIC], errColumn );
gMessageCount=AddToMsgArray( gMessageIDs, INIT_MESSAGE_INVNUMERIC, gMessageCount, MAX_INIT_MESSAGE_COUNT );
break;
default:
break;
}
if (keyData[1].value && // check for HCD layer drivers
!CheckHCDDriversLoaded( cmdLine, LOUSHORT(keyData[1].value), HIUSHORT(keyData[1].value) ))
{
pRP->Status = STATUS_DONE | STERR | ERROR_I24_QUIET_INIT_FAIL; // 05/16/2000 MB - exit code changed to quiet exit code
gMessageCount=AddToMsgArray( gMessageIDs, INIT_MESSAGE_NO_HCD, gMessageCount, MAX_INIT_MESSAGE_COUNT );
}
gVerbose= keyData[0].keyStatus!=CFSTR_STATUS_NOTFOUND;
gDelayHostStart = keyData[2].keyStatus!=CFSTR_STATUS_NOTFOUND; // 31/05/1999 MB
if(gDelayHostStart && (pRP->Status == STATUS_DONE) ) // 05/16/2000 MB - fixed error code processing
{
USHORT ctxOffset;
USHORT rc;
ctxOffset=(USHORT)(LONG)(StartHostCtxHookRtn); // IRQ processing thread
rc = DevHelp_AllocateCtxHook((NPFN)ctxOffset, &gStartHostHookHandle);
if (rc)
{
pRP->Status = STATUS_DONE | STERR | STATUS_ERR_UNKCMD;
gMessageCount=AddToMsgArray( gMessageIDs, INIT_MESSAGE_SETCTXFAILED, gMessageCount, MAX_INIT_MESSAGE_COUNT );
#ifdef DEBUG
dsPrint(DBG_CRITICAL, " USBD: USBDInit failed to allocate CTX hook routine\r\n");
#endif
}
}
/*---------------------------------------------------*/
/* Register device driver with resource manager */
/*---------------------------------------------------*/
if (pRP->Status == STATUS_DONE)
RegisterUSBD();
if (pRP->Status == STATUS_DONE)
{
// initialize local structures
setmem((PSZ)&gHostControllers,0,sizeof(gHostControllers));
setmem((PSZ)&gClassDrivers,0,sizeof(gClassDrivers));
setmem((PSZ)&gDevices,0,sizeof(gDevices));
setmem((PSZ)&gHubs,0,sizeof(gHubs));
for (ctrlID=1; ctrlID<gMaxControllers; ctrlID++)
{
gSetAddress[ctrlID]=gSetAddress[0];
gSetConfiguration[ctrlID]=gSetConfiguration[0];
gDeviceStruct[ctrlID]=gDeviceStruct[0];
gGetConfiguration[ctrlID]=gGetConfiguration[0];
gGetHubConfigurationLength[ctrlID]=gGetHubConfigurationLength[0];
}
}
if (pRP->Status == STATUS_DONE)
{
SetLongValue( gVMessages[INIT_MESSAGE_LOADED], (ULONG)gDriverStruct.MajorVer );
SetLongValue( gVMessages[INIT_MESSAGE_LOADED], (ULONG)gDriverStruct.MinorVer );
gMessageCount=AddToMsgArray( gMessageIDs, INIT_MESSAGE_LOADED, gMessageCount, MAX_INIT_MESSAGE_COUNT );
pRPO->CodeEnd = ((USHORT) &USBInit) - 1; /* set end of code segment */
pRPO->DataEnd = ((USHORT) &gInitDataStart) - 1; /* set end of data segment */
}
else
{
pRPO->CodeEnd = 0; /* set end of code segment */
pRPO->DataEnd = 0; /* set end of data segment */
}
TTYWrite(gVMessages, gMessageIDs, gMessageCount);
#ifdef DEBUG
dsPrint1(DBG_HLVLFLOW, "USBD: USBInit ended. Status %x\r\n", pRP->Status);
#endif
return;
}
/* initialize the cell matrix to all dead */
clear()
{
setmem(cell,(XSIZE*YSIZE),0);
}
