void build_entry(w16 **tptr, struct BAS_PFENTRY *p, w16 **iptr)
{
w16 *t;
int l;
/*printf("build_entry %s, code at %d\n",p->name,(long)(*iptr)-(long)theROM);*/
WW(*iptr,BASEXT_CMD_CODE); /* make the subr and */
p->code_addr=(w32)((char*)*iptr-(char*)theROM); /* store the entry addr */
t=*tptr;
if ((int)t&1)
{
printf("basic extension problem\n");
cleanup(3);
}
WW(t,(char*)*iptr-(char*)t);
t++;
*(char *)t=l=strlen(p->name)&255;
t=(w16 *)((char*)t+1);
strncpy((char *)t,p->name,l);
t=(w16*)((char*)t+l); /* L !!*/
if ((int)t&1) t=(w16*)((char*)t+1);
*tptr=t;
*iptr=(*iptr)+1;
/*printf("iptr: %d\n",*iptr);*/
}
static Cond InstallQemlRom(void)
{
if(!qemlPatch)
{
if (isMinerva)
{
ROMINIT_CMD_ADDR=0x0;
qemlPatch=LookFor2(&ROMINIT_CMD_ADDR,0x0c934afbl,1,48*1024);
if (testMinervaVersion("1.89"))
{
uw32 mpatch_addr=0x4e6;
if(V3)printf("Minerva 1.89, checking for >1MB patch\n");
if ( RW((Ptr)theROM+mpatch_addr)==0xd640 )
{
WW((Ptr)theROM+mpatch_addr,0xd680);
if(V3)printf("....applied patch\n");
}
}
}
else /* not Minerva */
{
ROMINIT_CMD_ADDR=0x4a00;
qemlPatch=LookFor(&ROMINIT_CMD_ADDR,0x0c934afbl,1000);
}
if (!qemlPatch)
printf("Warning: could not patch ROM scan sequence\n");
if(qemlPatch)
{
WW(((uw16*)((Ptr)theROM+ROMINIT_CMD_ADDR)),ROMINIT_CMD_CODE);
WW(((uw16*)((Ptr)theROM+MDVIO_CMD_ADDR)),MDVIO_CMD_CODE); /* device driver routines */
WW(((uw16*)((Ptr)theROM+MDVO_CMD_ADDR)),MDVO_CMD_CODE);
WW(((uw16*)((Ptr)theROM+MDVC_CMD_ADDR)),MDVC_CMD_CODE);
WW(((uw16*)((Ptr)theROM+MDVSL_CMD_ADDR)),MDVSL_CMD_CODE);
WW(((uw16*)((Ptr)theROM+MDVFO_CMD_ADDR)),MDVFO_CMD_CODE);
#ifdef SERIAL
#ifndef NEWSERIAL
if(isMinerva)
{
printf("sorry, old style SER driver won't work\n");
return qemlPatch;
}
else
{
WW (((uw16 *) ((Ptr) theROM + 0xbb6l)), OSERIO_CMD_CODE); /* I/O */
WW (((uw16 *) ((Ptr) theROM + 0xad0l)), OSERO_CMD_CODE); /* Open */
WW (((uw16 *) ((Ptr) theROM + 0xb8el)), OSERC_CMD_CODE); /* Close */
}
#else
#warning UNUSED NEWSERIAL
#endif
#else
#warning UNUSED SERIAL
#endif
}
}
return qemlPatch;
}
static void InitDevDriver(struct DRV *driver, int indx)
{
w32 savedRegs[4];
w32 *p;
char *name=(driver->namep)->name;
BlockMoveData(aReg,savedRegs,4*sizeof(w32));
reg[1]=40+strlen(name);
if((strlen(name)&1)!=0) reg[1]++;
if (driver->slot != 0)
{
if(driver->slot <reg[1])
{
printf("requested driver size for driver %s too small: %d\n",*name,driver->slot);
goto ddier;
}
reg[1]=driver->slot;
}
reg[2]=0;
QLtrap(1,0x18,200000l); /* allocate memory for the driver linkage block */
if((*reg)==0)
{
driver->ref=aReg[0];
p=(w32*)(aReg[0]+(Ptr)theROM+4);
WL(p,DEV_IO_ADDR); /* io */
WL(p+1,(w32) ((Ptr)(p+3)-(Ptr)theROM)); /* open */
WL(p+2,DEV_CLOSE_ADDR); /* close */
WW(p+3,DEVO_CMD_CODE);
strcpy((Ptr)(p+6)+4,name); /* name for QPAC2 etc */
WW((Ptr)(p+3+3)+2,strlen(name));
WL((Ptr)(p+3)+2,0x264f4eba); /* so much code is needed to fool QPAC2 ...*/
WL((Ptr)(p+4)+2,0x2c566046);
WL((Ptr)(p+5)+2,0x6044604a);
if ((*(driver->init))(indx,p-1) <0)
goto ddier;
QLtrap(1,0x20,20000l); /* link directory device driver in IOSS */
}
ddier:
BlockMoveData(savedRegs,aReg,4*sizeof(w32));
}
void InitDrivers()
{
struct DRV *p=Drivers;
DEV_IO_ADDR=0x14020;
DEV_CLOSE_ADDR=0x14022;
/* DEV_OPEN_ADDR=0x14024;*/
WW(((uw16*)((Ptr)theROM+DEV_IO_ADDR)),DEVIO_CMD_CODE);
WW(((uw16*)((Ptr)theROM+DEV_CLOSE_ADDR)),DEVC_CMD_CODE);
/*WW(((uw16*)((Ptr)theROM+DEV_OPEN_ADDR)),DEV_OPEN_INSTR);*/
table[DEVO_CMD_CODE]=DrvOpen;
table[DEVIO_CMD_CODE]=DrvIO;
table[DEVC_CMD_CODE]=DrvClose;
while (p->open!=NULL)
{
InitDevDriver(p++,p-Drivers);
num_drivers++;
}
}
void init_poll()
{
reg[1]=0x10;
reg[2]=0;
QLtrap(1,0x18,2000000l);
if (*reg==0)
{
Ptr p=(Ptr)theROM+aReg[0];
p = p + 4;
WL( p, POLL_CMD_ADDR);
WW((Ptr)theROM+POLL_CMD_ADDR, POLL_CMD_CODE);
QLtrap(1,0x1c,200000l);
}
}
int main() {
drzewo drz; Boolean ok;
// Wczytanie pierwszego znaku (z pominieciem niewidocznych:
do { scanf("%c", &leks); }
while ((leks < '!' || leks > '~') && leks != '\n');
ok = WW(&drz); printf ("\n");
if (ok && leks == '\n') drukuj_drzewo (drz);
else
if (ok && leks != '\n') {
drukuj_drzewo (drz);
printf (" SMIECI NA KONCU: %c\n\n", leks);
}
else printf (" NAPIS BLEDNY\n\n");
return 0;
}
// <T> ::= b <T> c | e
Boolean SS (drzewo* drz) {
drzewo drz1;
if (nowyleks('('))
if (WW(&drz1))
if (nowyleks(')')) {
// Rozpoznalismy w <T> , robimy z tego drzewo:
drz->czyterm = FALSE;
drz->ntm = S;
drz->il_syn = 3;
drz->syn[0] = (drzewo*)malloc(sizeof(drzewo));
drz->syn[0]->czyterm = TRUE;
drz->syn[0]->lk = '(';
drz->syn[1] = (drzewo*)malloc(sizeof(drzewo));
*(drz->syn[1]) = drz1;
drz->syn[2] = (drzewo*)malloc(sizeof(drzewo));
drz->syn[2]->czyterm = TRUE;
drz->syn[2]->lk = ')';
return TRUE;
}
else return blad("( <W> ??? -- oczekiwalem ')' ");
else return blad("( ??? -- oczekiwalem <W> ");
else
if(nowyleks('a')) {
// Rozpoznalismy tylko e , robimy z niego drzewo:
drz->czyterm = FALSE;
drz->ntm = S;
drz->il_syn = 1;
drz->syn[0] = (drzewo*)malloc(sizeof(drzewo));
drz->syn[0]->czyterm = TRUE;
drz->syn[0]->lk = 'a';
return TRUE;
}
else return FALSE;
}
int mri_warp3D_align_setup( MRI_warp3D_align_basis *bas )
{
MRI_IMAGE *cim , *fitim ;
int nx, ny, nz, nxy, nxyz , ii,jj,kk , nmap, *im ;
float *wf , *wtar , clip , clip2 ;
int *ima , pp , wtproc , npar , nfree ;
byte *msk ;
int ctstart ;
ENTRY("mri_warp3D_align_setup") ;
ctstart = NI_clock_time() ;
/*- check for good inputs -*/
if( bas == NULL || bas->imbase == NULL ) RETURN(1) ;
if( bas->nparam < 1 || bas->param == NULL ) RETURN(1) ;
if( bas->vwfor == NULL ||
bas->vwinv == NULL || bas->vwset == NULL ) RETURN(1) ;
/*- set defaults in bas, if values weren't set by user -*/
if( bas->scale_init <= 0.0f ) bas->scale_init = 1.0f ;
if( bas->delfac <= 0.0f ) bas->delfac = 1.0f ;
if( bas->regmode <= 0 ) bas->regmode = MRI_LINEAR ;
if( bas->max_iter <= 0 ) bas->max_iter = 9 ;
/* process the weight image? */
wtproc = (bas->imwt == NULL) ? 1 : bas->wtproc ;
npar = bas->nparam ;
nfree = npar ;
for( pp=0 ; pp < npar ; pp++ )
if( bas->param[pp].fixed ) nfree-- ;
if( nfree <= 0 ) RETURN(1) ;
bas->nfree = nfree ;
/*- clean out anything from last call -*/
mri_warp3D_align_cleanup( bas ) ;
/*-- need local copy of input base image --*/
cim = mri_to_float( bas->imbase ) ;
nx=cim->nx ; ny=cim->ny ; nz=cim->nz ; nxy = nx*ny ; nxyz=nxy*nz ;
/*-- make weight image up from the base image if it isn't supplied --*/
if( bas->verb ) fprintf(stderr,"++ mri_warp3D_align_setup ENTRY\n") ;
if( bas->imwt == NULL ||
bas->imwt->nx != nx ||
bas->imwt->ny != ny ||
bas->imwt->nz != nz ) bas->imww = mri_copy( cim ) ;
else bas->imww = mri_to_float( bas->imwt ) ;
if( bas->twoblur > 0.0f ){
float bmax = cbrt((double)nxyz) * 0.03 ;
if( bmax < bas->twoblur ){
if( bas->verb )
fprintf(stderr,"+ shrink bas->twoblur from %.3f to %.3f\n",
bas->twoblur , bmax ) ;
bas->twoblur = bmax ;
}
}
if( bas->verb ) fprintf(stderr,"+ processing weight:") ;
/* make sure weight is non-negative */
wf = MRI_FLOAT_PTR(bas->imww) ;
for( ii=0 ; ii < nxyz ; ii++ ) wf[ii] = fabs(wf[ii]) ;
/* trim off edges of weight */
if( wtproc ){
int ff ;
int xfade=bas->xedge , yfade=bas->yedge , zfade=bas->zedge ;
if( xfade < 0 || yfade < 0 || zfade < 0 )
mri_warp3D_align_edging_default(nx,ny,nz,&xfade,&yfade,&zfade) ;
if( bas->twoblur > 0.0f ){
xfade += (int)rint(1.5*bas->twoblur) ;
yfade += (int)rint(1.5*bas->twoblur) ;
zfade += (int)rint(1.5*bas->twoblur) ;
}
if( 3*zfade >= nz ) zfade = (nz-1)/3 ;
if( 3*xfade >= nx ) xfade = (nx-1)/3 ;
if( 3*yfade >= ny ) yfade = (ny-1)/3 ;
if( bas->verb ) fprintf(stderr," [edge(%d,%d,%d)]",xfade,yfade,zfade) ;
for( jj=0 ; jj < ny ; jj++ )
for( ii=0 ; ii < nx ; ii++ )
for( ff=0 ; ff < zfade ; ff++ )
WW(ii,jj,ff) = WW(ii,jj,nz-1-ff) = 0.0f ;
for( kk=0 ; kk < nz ; kk++ )
for( jj=0 ; jj < ny ; jj++ )
for( ff=0 ; ff < xfade ; ff++ )
WW(ff,jj,kk) = WW(nx-1-ff,jj,kk) = 0.0f ;
for( kk=0 ; kk < nz ; kk++ )
for( ii=0 ; ii < nx ; ii++ )
for( ff=0 ; ff < yfade ; ff++ )
WW(ii,ff,kk) = WW(ii,ny-1-ff,kk) = 0.0f ;
}
/* spatially blur weight a little */
if( wtproc ){
float blur ;
blur = 1.0f + MAX(1.5f,bas->twoblur) ;
if( bas->verb ) fprintf(stderr," [blur(%.1f)]",blur) ;
EDIT_blur_volume_3d( nx,ny,nz , 1.0f,1.0f,1.0f ,
MRI_float , wf , blur,blur,blur ) ;
}
/* get rid of low-weight voxels */
clip = 0.035 * mri_max(bas->imww) ;
clip2 = 0.5*THD_cliplevel(bas->imww,0.4) ;
if( clip2 > clip ) clip = clip2 ;
if( bas->verb ) fprintf(stderr," [clip(%.1f)]",clip) ;
for( ii=0 ; ii < nxyz ; ii++ ) if( wf[ii] < clip ) wf[ii] = 0.0f ;
/* keep only the largest cluster of nonzero voxels */
{ byte *mmm = (byte *)malloc( sizeof(byte)*nxyz ) ;
for( ii=0 ; ii < nxyz ; ii++ ) mmm[ii] = (wf[ii] > 0.0f) ;
THD_mask_clust( nx,ny,nz, mmm ) ;
THD_mask_erode( nx,ny,nz, mmm, 1 ) ; /* cf. thd_automask.c */
THD_mask_clust( nx,ny,nz, mmm ) ;
for( ii=0 ; ii < nxyz ; ii++ ) if( !mmm[ii] ) wf[ii] = 0.0f ;
free((void *)mmm) ;
}
if( bas->verb ) fprintf(stderr,"\n") ;
/*-- make integer index map of weight > 0 voxels --*/
nmap = 0 ;
for( ii=0 ; ii < nxyz ; ii++ ) if( wf[ii] > 0.0f ) nmap++ ;
if( bas->verb )
fprintf(stderr,"+ using %d [%.3f%%] voxels\n",nmap,(100.0*nmap)/nxyz);
if( nmap < 7*nfree+13 ){
fprintf(stderr,"** mri_warp3D_align error: weight image too zero-ish!\n") ;
mri_warp3D_align_cleanup( bas ) ; mri_free(cim) ;
RETURN(1) ;
}
bas->imap = mri_new( nmap , 1 , MRI_int ) ;
ima = MRI_INT_PTR(bas->imap) ;
bas->imsk = mri_new_conforming( bas->imww , MRI_byte ) ;
msk = MRI_BYTE_PTR(bas->imsk) ;
for( ii=jj=0 ; ii < nxyz ; ii++ ){
if( wf[ii] > 0.0f ){ ima[jj++] = ii; msk[ii] = 1; }
}
/* make copy of sqrt(weight), but only at mapped indexes */
wtar = (float *)malloc(sizeof(float)*nmap) ;
for( ii=0 ; ii < nmap ; ii++ ) wtar[ii] = sqrt(wf[ima[ii]]) ;
/*-- for parameters that don't come with a step size, find one --*/
clip = bas->tolfac ; if( clip <= 0.0f ) clip = 0.03f ;
for( ii=0 ; ii < npar ; ii++ ){
if( bas->param[ii].fixed ) continue ; /* don't need this */
if( bas->param[ii].delta <= 0.0f )
mri_warp3D_get_delta( bas , ii ) ; /* find step size */
if( bas->param[ii].toler <= 0.0f ){ /* and set default tolerance */
bas->param[ii].toler = clip * bas->param[ii].delta ;
if( bas->verb )
fprintf(stderr,"+ set toler param#%d [%s] = %f\n",
ii+1,bas->param[ii].name,bas->param[ii].toler) ;
}
}
/* don't need the computed weight image anymore */
mri_free(bas->imww) ; bas->imww = NULL ; wf = NULL ;
/*-- create image containing basis columns, then pseudo-invert it --*/
if( bas->verb ) fprintf(stderr,"+ Compute Derivatives of Base\n") ;
fitim = mri_warp3D_align_fitim( bas , cim , bas->regmode , bas->delfac ) ;
if( bas->verb ) fprintf(stderr,"+ calculate pseudo-inverse\n") ;
bas->imps = mri_psinv( fitim , wtar ) ;
mri_free(fitim) ;
if( bas->imps == NULL ){ /* bad bad bad */
fprintf(stderr,"** mri_warp3D_align error: can't invert Base matrix!\n") ;
free((void *)wtar) ; mri_warp3D_align_cleanup( bas ) ; mri_free(cim) ;
RETURN(1) ;
}
/*--- twoblur? ---*/
if( bas->twoblur > 0.0f ){
float *car=MRI_FLOAT_PTR(cim) ;
float blur = bas->twoblur ;
float bfac = blur ;
if( bfac < 1.1234f ) bfac = 1.1234f ;
else if( bfac > 1.3456f ) bfac = 1.3456f ;
if( bas->verb ) fprintf(stderr,"+ Compute Derivatives of Blurred Base\n") ;
EDIT_blur_volume_3d( nx,ny,nz , 1.0f,1.0f,1.0f ,
MRI_float , car, blur,blur,blur ) ;
fitim = mri_warp3D_align_fitim( bas , cim , MRI_LINEAR , bfac*bas->delfac ) ;
if( bas->verb ) fprintf(stderr,"+ calculate pseudo-inverse\n") ;
bas->imps_blur = mri_psinv( fitim , wtar ) ;
mri_free(fitim) ;
if( bas->imps_blur == NULL ){ /* bad */
fprintf(stderr,"** mri_warp3D_align error: can't invert Blur matrix!\n") ;
}
}
/*--- done ---*/
mri_free(cim) ; free((void *)wtar) ;
if( bas->verb ){
double st = (NI_clock_time()-ctstart) * 0.001 ;
fprintf(stderr,"++ mri_warp3D_align_setup EXIT: %.2f seconds elapsed\n",st);
}
RETURN(0);
}
static void mri_warp3D_get_delta( MRI_warp3D_align_basis *bas , int kpar )
{
float *pvec , dpar ;
int ii,jj,kk , nx,ny,nz,nxy , nite , ntot ;
float xx,yy,zz , tx,ty,tz , dt,dtot ;
float *wf ;
if( bas == NULL || kpar < 0 || kpar >= bas->nparam ) return ;
if( bas->param[kpar].fixed ) return ;
/* load parameter vector with the identity value for all params */
pvec = (float *)malloc(sizeof(float) * bas->nparam) ;
for( ii=0 ; ii < bas->nparam ; ii++ )
pvec[ii] = (bas->param[ii].fixed) ? bas->param[ii].val_fixed
: bas->param[ii].ident ;
nx = bas->imbase->nx ; ny = bas->imbase->ny ; nz = bas->imbase->nz ;
nxy = nx*ny ;
/* initial value for delta */
dpar = 0.001 * ( fabs(bas->param[kpar].ident) + 1.0 ) ;
nite = 0 ; wf = MRI_FLOAT_PTR(bas->imww) ;
/* iterate:
- compute transformation over all points with positive weight
- compute distance moved
- compute RMS of positive distances moved
- adjust dpar up or down to move RMS distance moved towards 1.0 */
if( bas->verb )
fprintf(stderr,"+ get_delta param#%d [%s]: %f" ,
kpar+1, bas->param[kpar].name , dpar ) ;
while(1){
pvec[kpar] = bas->param[kpar].ident + dpar ; /* set param */
bas->vwset( bas->nparam , pvec ) ; /* load transform */
ntot = 0 ; dtot = 0.0f ;
for( kk=0 ; kk < nz ; kk++ ){
zz = (float)kk ;
for( jj=0 ; jj < ny ; jj++ ){
yy = (float)jj ;
for( ii=0 ; ii < nx ; ii++ ){
if( WW(ii,jj,kk) == 0.0f ) continue ; /* not counted */
xx = (float)ii ;
/* forward transform */
bas->vwfor( xx,yy,zz , &tx,&ty,&tz ) ;
dt = (tx-xx)*(tx-xx) + (ty-yy)*(ty-yy) + (tz-zz)*(tz-zz) ;
if( dt > 0.0f ){ ntot++ ; dtot += dt ; }
/* inverse transform */
bas->vwinv( xx,yy,zz , &tx,&ty,&tz ) ;
dt = (tx-xx)*(tx-xx) + (ty-yy)*(ty-yy) + (tz-zz)*(tz-zz) ;
if( dt > 0.0f ){ ntot++ ; dtot += dt ; }
}}}
if( ntot > 0 ){
dtot = sqrt( dtot/ntot ) ; /* RMS positive distance moved */
if( dtot > 0.909f && dtot < 1.100f ) break ; /* good enough! */
dtot = 1.0f / dtot ; /* dpar adjustment factor */
if( dtot > 50.0f ) dtot = 50.0f ;
else if( dtot < 0.02f ) dtot = 0.02f ;
} else {
dtot = 50.0f ; /* no movement? how peculiar! */
}
dpar *= dtot ; /* adjust dpar, up or down */
if( bas->verb ) fprintf(stderr," %f",dpar) ;
nite++ ; if( nite > 9 ) break ;
} /* end of iteration loop */
if( bas->verb ) fprintf(stderr,"\n") ;
bas->param[kpar].delta = dpar ; /* save result, whatever it is */
/* 11 Jan 2005: use this result to scale min..max up, if needed */
dt = AFNI_numenv("AFNI_3dWarpDrive_dfac") ;
if( dt <= 1.0f ) dt = 1.666f ;
dpar = dt * dpar ;
if( bas->param[kpar].ident == 0.0f && dpar > bas->param[kpar].max ){
bas->param[kpar].min = -dpar ;
bas->param[kpar].max = dpar ;
if( bas->verb )
fprintf(stderr,"+ reset range to %f .. %f\n",
bas->param[kpar].min,bas->param[kpar].max) ;
}
free((void *)pvec) ;
return ;
}
void InitROM(void)
{
w32 saved_regs[16];
char qvers[6];
char *initstr="UQLX v%s, release\012 %s\012QDOS Version %s\012";
long sysvars,sxvars;
if((long)((Ptr)gPC-(Ptr)theROM)-2 != ROMINIT_CMD_ADDR)
{ exception=4;
extraFlag=true;
return;
}
#if 0
printf("a6=%x, basic at %x\n",aReg[6],ReadLong(0x28010));
#endif
save_regs(saved_regs);
do_update=1; /* flip in screen RAM */
#ifdef OLD_PATCH
/* lea $0C000,a3 */
aReg[3]=0x0c000;
gPC+=2;
#else
#warning UNUSED OLD_PATCH
WW((Ptr)gPC-2,0x0c93); /* restore original instruction */
#endif
#if 0
KillSound();
CloseSerial();
InitSerial();
ZeroKeyboardBuffer();
#endif
/* delete old MDV drivers (for optical reasons) */
WriteLong(0x28048,0);
InitFileDrivers();
InitDrivers();
#ifdef XSCREEN
/*printf("call init_xscreen\n");*/
init_xscreen();
#else
#warning UNUSED XSCREEN
#endif
SchedInit();
init_bas_exts();
QLtrap(1,0,20000l);
#if 0
printf("QDOS vars at %x, trap res=%d, RTOP=%d\n",aReg[0],reg[0],RTOP);
#endif
sysvars=aReg[0];
sxvars=RL((Ptr)theROM+sysvars+0x7c);
#if 0
if (isMinerva)
printf("Minerva extended vars at %x\n",sxvars);
#endif
if (V3)
printf("sysvars at %x, ux RAMTOP %d, sys.ramt %d, qlscreen at %d\n",
sysvars,RTOP,sysvar_l(20),qlscreen.qm_lo);
// QDOS version
WL((Ptr)qvers,reg[2]);qvers[4]=0;
#if 0
p=(Ptr)theROM+RTOP-0x07FFEl;
sprintf(p,initstr,uqlx_version,release,qvers);
WriteWord(aReg[1]=RTOP-0x08000l,strlen(p));
#if 1
QLvector(0xd0,200000);
#else
WriteLong((*sp)-=4,(w32)gPC-(w32)theROM);
gPC=(uw16*)((Ptr)theROM+RW((uw16*)((Ptr)theROM+0xd0))); /* write string */
#endif
#endif
/*HACK: allow breakpoints in ROM*/
#if DEBUG_ROM
RamMap[0]=RamMap[1]=RamMap[2]=3;
uqlx_protect(0,3*32768,QX_RAM);
#endif
/* now install TKII defaults */
reg[1]=0x6c;
reg[2]=0;
QLtrap(1,0x18,200000);
if(reg[0]==0){
if (V3)printf("Initialising TK2 device defaults\n");
WriteLong(0x28070+0x3c,aReg[0]);
WriteLong(0x28070+0x40,32+aReg[0]);
WriteLong(0x28070+0x44,64+aReg[0]);
WriteWord(aReg[0],strlen(DATAD));strcpy((char*)((Ptr)theROM+aReg[0]+2),DATAD);
WriteWord(aReg[0]+32,strlen(PROGD));strcpy((char*)((Ptr)theROM+aReg[0]+34),PROGD);
WriteWord(aReg[0]+64,strlen(SPOOLD));strcpy((char*)((Ptr)theROM+aReg[0]+66),SPOOLD);
}
/* link in Minerva keyboard handling */
#if 1
if (isMinerva)
{
reg[1]=8;
reg[2]=0;
QLtrap(1,0x18,200000);
if(reg[0]==0)
{
WW((Ptr)theROM+MIPC_CMD_ADDR,MIPC_CMD_CODE);
WL((Ptr)theROM+aReg[0],RL((Ptr)theROM+sxvars+0x14));
WL((Ptr)theROM+aReg[0]+4,MIPC_CMD_ADDR);
WL((Ptr)theROM+sxvars+0x14,aReg[0]);
}
WW((Ptr)theROM+KBENC_CMD_ADDR,KBENC_CMD_CODE);
orig_kbenc=RL((Ptr)theROM+sxvars+0x10);
WL((Ptr)theROM+sxvars+0x10,KBENC_CMD_ADDR);
#if 0
printf("orig_kbenc=%x\nreplacement kbenc=%x\n",orig_kbenc,KBENC_CMD_ADDR);
printf("sx_kbenc addr=%x\n",sxvars+0x10);
#endif
}
#endif
init_poll();
/* make sure it wasn't changed somewhere */
restore_regs(saved_regs);
#ifdef OLD_PATCH
aReg[3]=0x0c000;
#endif
#ifndef OLD_PATCH
table[code=0x0c93](); /* run the original routine */
#endif
}
short LoadMainRom(void) /* load and modify QL ROM */
{
short e;
long l;
w32 a;
Cond p;
qemlPatch=false;
p=1;/*ReasonableROM(theROM);*/
isMinerva=testMinerva();
if (isMinerva)
if(V3)printf("using Minerva ROM\n");
//if(V1)printf("no_patch: %d\n",QMD.no_patch);
if (p && !QMD.no_patch)
{
if (!isMinerva)
{
if(p) p=PatchFind();
if(p)
{
WW((((Ptr)theROM+IPC_CMD_ADDR)), IPC_CMD_CODE);
WW((((Ptr)theROM+IPCR_CMD_ADDR)), IPCR_CMD_CODE);
WW((((Ptr)theROM+IPCW_CMD_ADDR)), IPCW_CMD_CODE);
}
}
WW((((Ptr)theROM+0x4000+RW((uw16*)((Ptr)theROM+0x124)))), MDVR_CMD_CODE); /* read mdv sector */
WW((((Ptr)theROM+0x4000+RW((uw16*)((Ptr)theROM+0x126)))), MDVW_CMD_CODE); /* write mdv sector */
WW(((uw16*)((Ptr)theROM+0x4000+RW((uw16*)((Ptr)theROM+0x128)))), MDVV_CMD_CODE); /* verify mdv sector */
WW(((uw16*)((Ptr)theROM+0x4000+RW((uw16*)((Ptr)theROM+0x12a)))), MDVH_CMD_CODE); /* read mdv sector header */
if(!isMinerva && QMD.fastStartup) WW(((uw16*)((Ptr)theROM+RL(&theROM[1]))), FSTART_CMD_CODE); /* fast startup patch */
/* FastStartup() -- 0xadc7 */
if (!isMinerva)
{
/* correct bugs which crashes the QL with 4M ram */
a=0x250;
p=LookFor(&a,0xd6c028cb,6);
if(p)
{ WW(((uw16*)((Ptr)theROM+a)),0xd7c0);
a=0x3120;
p=LookFor(&a,0xd2c02001,250);
}
else if(V3)printf("looks like ROM doesn't have 16MB bugs\n");
if(p)
{ WW(((uw16*)((Ptr)theROM+a)),0xd3c0);
a=0x4330;
p=LookFor(&a,0x90023dbc,120);
if(p) WW(((uw16*)((Ptr)theROM+a)),0x9802);
}
PatchKeyTrans();
}
p=InstallQemlRom();
}
if (!p && !QMD.no_patch) printf("warning : could not complete ROM patch\n");
/* last not least intrument the ROM code HW register access */
instrumentCode();
if(e==0 && !p) e=ERR_ROM_UNKNOWN;
return e;
}
static void PatchKeyTrans(void)
{
KEYTRANS_CMD_ADDR=RL((Ptr)theROM+0xbff2);
KEYTRANS_OCODE=RW((uw16*)((Ptr)theROM+KEYTRANS_CMD_ADDR));
WW(((uw16*)((Ptr)theROM+KEYTRANS_CMD_ADDR)),KEYTRANS_CMD_CODE);
}
void create_link_table(struct BAS_PFENTRY *list)
{
int tsize,inst_size,f_cnt,p_cnt;
struct BAS_PFENTRY *p;
w32 bext_table;
w16 *etab;
w16 *instr;
int fnccnt,pccnt;
pccnt=fnccnt=f_cnt=p_cnt=0;
tsize=2+2+4+2; /*count,count, end markers */
inst_size=0;
/* somewhat generously counting */
p=list;
while(p)
{ /* len +.b+allign+addr */
tsize+= (((strlen(p->name)+1)>>1)<<1)+2;
inst_size+=2;
switch(p->type)
{
case X_FUN:
f_cnt++;
fnccnt+=strlen(p->name);
break;
case X_PROC:
p_cnt++;
pccnt+=strlen(p->name);
break;
default:
fprintf(stderr,"wrong basic extension type %d\n",p->type);
return;
}
p=p->link;
}
reg[1]=tsize+inst_size+12+100; /* some pad */
reg[2]=0;
/*printf("totsize %d, tsize %d, inst_size %d,\n reserve %d\n",reg[1],tsize,inst_size,reg[1]);*/
#if 1
QLtrap(1,0x18,2000000);
if (reg[0])
{
fprintf(stderr,"allocation failed, QDOS error %d\n",reg[0]);
return;
}
#endif
#if 1
bext_table=aReg[0];
etab=(w16 *)((char*)theROM+aReg[0]);
instr=(w16 *)((char*)etab+(((tsize+6+10)>>1)<<1));
WW(etab++,mangle_count(pccnt,p_cnt));
p=ext_list;
while(p_cnt--)
{
fnext(X_PROC,&p);
build_entry(&etab,p,&instr);
p=p->link;
}
WW(etab++,0); /* end proc marker */
WW(etab++,mangle_count(fnccnt,f_cnt));
p=ext_list;
while(f_cnt--)
{
fnext(X_FUN,&p);
build_entry(&etab,p,&instr);
p=p->link;
}
WW(etab++,0); /* end fun marker */
WW(etab++,0); /* another marker to be sure */
/*printf("Basic Extensions table at %d\n",bext_table);*/
#endif
#if 1
aReg[1]=bext_table;
QLvector(0x110,2000000); /* and BP.INIT */
#endif
}
