word SaveBoot( byte Device, byte PartyID, MasterBootRecord *pBR )
// in futute it should read all track ( MBR should be duplicated )
{
MasterBootRecord MBR;
if( LoadMasterBoot( Device, &MBR ) )
{
return ERR_FS_FATAL_ERROR;
}
// before save check if boot is valid
if( pBR->PartyTable.ID != 0xAA55 )
{
#ifdef SEE_ERROR
printf("\n Error: SaveBoot - magic 0xAA55 not found");
#endif
// recovery using The Second Boot Record
TheSecondBoot SecondBoot;
// read second boot
ReadLogicalSector( Device,
MBR.PartyTable.Party[PartyID-1].FirstSectorOff+1lu,
MK_FP( FP_SEG(&SecondBoot), FP_OFF(&SecondBoot) )
);
// copy BPB
movmem( (const void *)&(SecondBoot.BPB),
(void *)&(pBR->BPB),
sizeof(BIOSParameterBlock)
);
// copy OSID
movmem( (const void *)&(SecondBoot.OSID),
(void *)&(pBR->OSID),
sizeof(MBROSID)
);
// put magic
pBR->PartyTable.ID = 0xAA55;
SaveBoot( Device, PartyID, pBR );
#ifdef SEE_ERROR
printf(" => recovered... ");
#endif
}
// log. nr. of sector with BR: MBR.PartyTable.Party[PartyID-1].FirstSectorOff
if( WriteLogicalSector( Device,
MBR.PartyTable.Party[PartyID-1].FirstSectorOff,
MK_FP( FP_SEG(pBR), FP_OFF(pBR) ) )
)
return ERR_FS_FATAL_ERROR;
return ERR_FS_NO_ERROR;
}
/*
* recvd - gets upcalled when data arrives
*/
static int _recvdaemon( sock_type *s, byte *data, int len, tcp_PseudoHeader *ph, void *h)
{
recv_data *r;
recv_buf *p;
tcp_Socket *t;
int i;
udp_Header *uh;
/* check for length problem */
if ( !len || (len >= 1500 )) return( 0 );
switch ( s->udp.ip_type ) {
case UDP_PROTO :r = (recv_data*)(s->udp.rdata);
uh = (udp_Header *) h;
if (r->recv_sig != RECV_USED ) {
outs("ERROR: udp recv data conflict");
return( 0 );
}
p = (recv_buf *)(r->recv_bufs);
/* find a buffer */
for ( i = 0; i < r->recv_bufnum ; ++i , ++p) {
switch ( p->buf_sig ) {
case RECV_USED : break;
case RECV_UNUSED :
/* take this one */
p->buf_sig = RECV_USED;
p->buf_len = len;
p->buf_hisip = ph->src;
p->buf_hisport = uh->srcPort;
movmem( data, p->buf_data, len );
return( 0 );
default :
outs("ERROR: sock_recv_init data err");
return( 0 );
}
}
break;
case TCP_PROTO :
t= (tcp_Socket*)s;
r = (recv_data*)(t->rdata);
if (r->recv_sig != RECV_USED ) {
outs("ERROR: udp recv data conflict");
return( 0 );
}
/* stick it on the end if you can */
i = t->maxrdatalen - t->rdatalen;
if ( i > 1 ) {
/* we can accept some of this */
if ( len > i ) len = i;
movmem( data, &r->recv_bufs[t->rdatalen], len );
t->rdatalen += len;
return( len );
}
break;
}
return( 0 ); /* didn't take none */
}
void movecolright(void)
/* Moves right one column */
{
int col, oldleftcol, oldrightcol;
unsigned char oldcolstart[SCREENCOLS];
movmem(colstart, oldcolstart, sizeof(colstart));
oldleftcol = leftcol;
oldrightcol = rightcol;
displaycell(curcol, currow, NOHIGHLIGHT, NOUPDATE);
if (curcol < rightcol)
curcol++;
else if (rightcol < (MAXCOLS - 1))
{
curcol++;
rightcol++;
setleftcol();
setrightcol();
if (oldrightcol >= leftcol)
scroll(LEFT, oldcolstart[leftcol - oldleftcol] - LEFTMARGIN,
LEFTMARGIN + 1, 3, 80, SCREENROWS + 2, WHITE);
clearlastcol();
for (col = oldrightcol + 1; col <= rightcol; col++)
displaycol(col, NOUPDATE);
}
} /* movecolright */
void movecolleft(void)
/* Moves left one column */
{
int col, oldleftcol;
unsigned char oldcolstart[SCREENCOLS];
oldleftcol = leftcol;
movmem(colstart, oldcolstart, sizeof(colstart));
displaycell(curcol, currow, NOHIGHLIGHT, NOUPDATE);
if (curcol > leftcol)
curcol--;
else if (leftcol != 0)
{
curcol--;
leftcol--;
setrightcol();
setleftcol();
if (oldleftcol <= rightcol)
scroll(RIGHT, colstart[oldleftcol - leftcol] - LEFTMARGIN, LEFTMARGIN + 1,
3, 80, SCREENROWS + 2, WHITE);
clearlastcol();
for (col = leftcol; col <= oldleftcol - 1; col++)
displaycol(col, NOUPDATE);
}
} /* movecolleft */
void
makebstr(ubyte *name, short nameLen, ubyte *buf)
{
*buf = nameLen;
++buf;
movmem(name, buf, nameLen);
buf[nameLen] = 0; // necessary for 1.3
}
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 */
void deleteString()
{
size_t len = curRec->len;
#if !defined(__FLAT__)
movmem( next( curRec ), curRec, size_t( (char *)lastRec - (char *)curRec ) );
#else
memcpy(curRec, next(curRec), size_t( (char *)lastRec - (char *)curRec ) );
#endif
lastRec = backup( lastRec, len );
}
int sock_recv_from( sock_type *s, long *hisip, word *hisport, char *buffer, int len, word flags )
{
tcp_Socket *t;
recv_data *r;
recv_buf *p;
int i;
flags=flags; /* get rid of warning */
r = (recv_data *) s->udp.rdata;
if (r->recv_sig != RECV_USED )
return( -1 );
switch ( s->udp.ip_type ) {
case UDP_PROTO :
p = (recv_buf *) r->recv_bufs;
/* find a buffer */
for ( i = 0; i < r->recv_bufnum ; ++i , ++p) {
switch ( p->buf_sig ) {
case RECV_UNUSED:
break;
case RECV_USED :
p->buf_sig = RECV_USED;
if ( len > p->buf_len ) len = p->buf_len;
movmem( p->buf_data, buffer, len );
if (hisip) *hisip = p->buf_hisip;
if (hisport) *hisport = p->buf_hisport;
p->buf_sig = RECV_UNUSED;
return( len );
default :
outs("ERROR: sock_recv_init data err");
return( 0 );
}
}
return( 0 );
case TCP_PROTO :
t = (tcp_Socket *) s;
if ( len > t->rdatalen ) len = t->rdatalen;
if ( len )
movmem( r->recv_bufs, buffer, len );
return( len );
}
return( 0 );
}
void deleterow(int row)
/* Deletes a row */
{
int counter, rowc;
for (counter = 0; counter <= lastcol; counter++)
deletecell(counter, row, NOUPDATE);
printfreemem();
if (row != MAXROWS - 1)
{
for (counter = 0; counter < MAXCOLS; counter++)
{
movmem(&cell[counter][row + 1], &cell[counter][row],
sizeof(CELLPTR) * (MAXROWS - row - 1));
movmem(&format[counter][row + 1], &format[counter][row], MAXROWS - row - 1);
}
}
else
{
for (counter = 0; counter <= lastcol; counter++)
{
cell[counter][MAXROWS - 1] = NULL;
format[counter][MAXROWS - 1] = DEFAULTFORMAT;
}
}
if ((lastrow >= row) && (lastrow > 0))
lastrow--;
for (counter = 0; counter <= lastcol; counter++)
{
for (rowc = 0; rowc <= lastrow; rowc++)
{
if ((cell[counter][rowc] != NULL) &&
(cell[counter][rowc]->attrib == FORMULA))
fixformula(counter, rowc, ROWDEL, row);
}
}
while (row <= bottomrow)
displayrow(row++, NOUPDATE);
changed = TRUE;
recalc();
} /* deleterow */
void insertrow(int row)
/* Inserts a row */
{
int counter, rowc;
if (lastrow == MAXROWS - 1)
{
for (counter = 0; counter <= lastcol; counter++)
deletecell(counter, lastrow, NOUPDATE);
printfreemem();
}
if (row != MAXROWS - 1)
{
for (counter = 0; counter < MAXCOLS; counter++)
{
movmem(&cell[counter][row], &cell[counter][row + 1],
sizeof(CELLPTR) * (MAXROWS - row - 1));
movmem(&format[counter][row], &format[counter][row + 1], MAXROWS - row - 1);
}
}
for (counter = 0; counter < MAXCOLS; counter++)
{
cell[counter][row] = NULL;
format[counter][row] = DEFAULTFORMAT;
}
lastrow = MAXROWS - 1;
setlastrow();
for (counter = 0; counter <= lastcol; counter++)
{
for (rowc = 0; rowc <= lastrow; rowc++)
{
if ((cell[counter][rowc] != NULL) &&
(cell[counter][rowc]->attrib == FORMULA))
fixformula(counter, rowc, ROWADD, row);
}
}
while (row <= bottomrow)
displayrow(row++, NOUPDATE);
changed = TRUE;
recalc();
} /* insertrow */
char *find_lineperinch(void)
{
static char x[7];
register i;
sprintf(x, "%4d", (unsigned) lineperpage * 1000 / pagelength);
for (i = 0; i < 4; i++) {
if (x[i] != '0') {
movmem(&x[i+1], &x[i+2], 4-i);
x[i+1] = '.';
break;
}
}
return x;
}
void insertString( uchar id, const char *str )
{
ushort len = strlen( str ) + 3;
while( len > historySize - ( (char *)lastRec - (char *)historyBlock ) )
{
ushort firstLen = historyBlock->len;
HistRec *dst = historyBlock;
HistRec *src = next( historyBlock );
#if !defined(__FLAT__)
movmem( src, dst, size_t( (char *)lastRec - (char *)src ) );
#else
memcpy( dst, src, size_t( (char *)lastRec - (char *)src ) );
#endif
lastRec = backup( lastRec, firstLen );
}
new( lastRec ) HistRec( id, str );
lastRec = next( lastRec );
}
/* ddextract
* extract the data from a response message.
* returns the appropriate status code and if the data is available,
* copies it into data
* dtype is the RR type; unpacker is the function to get the data
* from the RR.
*/
static longword ddextract( struct useek *qp, byte dtype,
unpacker_funct unpacker, void *data )
{
word i,j,nans,rcode;
struct rrpart *rrp;
byte *p,space[260];
nans = intel16(qp->h.ancount); /* number of answers */
rcode = DRCODE & intel16(qp->h.flags); /* return code for this message*/
if (rcode > 0)
return(rcode);
if (nans > 0 && /* at least one answer */
(intel16(qp->h.flags) & DQR)) { /* response flag is set */
p = (byte *)&qp->x; /* where question starts */
i = unpackdom((char*)space,(char*)p,(char*)qp); /* unpack question name */
/* spec defines name then QTYPE + QCLASS = 4 bytes */
p += i+4;
/*
* at this point, there may be several answers. We will take the first
* one which has an IP number. There may be other types of answers that
* we want to support later.
*/
while (nans-- > 0) { /* look at each answer */
i = unpackdom((char*)space,(char*)p,(char*)qp); /* answer name to unpack */
/* n_puts(space);*/
p += i; /* account for string */
rrp = (struct rrpart *)p; /* resource record here */
/*
* check things which might not align on 68000 chip one byte at a time
*/
if (!*p && *(p+1) == dtype && /* correct type and class */
!*(p+2) && *(p+3) == DIN) {
unpacker(data,rrp,qp); /* get data we're looking for */
return(0); /* successful return */
}
movmem(&rrp->rdlength,&j,2); /* 68000 alignment */
p += 10+intel16(j); /* length of rest of RR */
}
}
return(-1); /* generic failed to parse */
}
void writesenaste(void) {
BPTR fh;
long tiden;
time(&tiden);
Statstr.tid_inloggad=(tiden-logintime)/60;
Statstr.utloggtid=tiden;
NiKForbid();
movmem(&Servermem->senaste,&Servermem->senaste[1],sizeof(struct Inloggning)*(MAXSENASTE-1));
memcpy(Servermem->senaste,&Statstr,sizeof(struct Inloggning));
if(!(fh=Open("NiKom:DatoCfg/Senaste.dat",MODE_NEWFILE))) {
printf("Kunde inte öppna Senaste.dat\n");
NiKPermit();
return;
}
if(Write(fh,(void *)Servermem->senaste,sizeof(struct Inloggning)*MAXSENASTE)==-1)
printf("Fel under skrivandet av Senaste.dat\n");
Close(fh);
NiKPermit();
}
void main( int argc, char *argv[] )
{
if (argc!=4)
{
cout<<" argc "<<argc<<" \nUsage \n"<<argv[0]
<<" File_X_col File_To_Build_Spline File_To_Write\n"
<<" File_To_Build_Spline: NumX_Grid 50 Misfit 0.1+ data\n";
exit(1);
};
char tmp[256];
double Misf,Mis;
int NumX;
fstream f_out(argv[3],ios::out);
TData<real> *in=NULL,*in1=NULL,*out=NULL;
cout<<" coreleft "<<coreleft()<<"\n";
InputTDataF(argv[1],in);
cout<<" NC "<<in->N<<" NR "<<in->I[0]<<"\n";
InputTDataF(argv[2],in1);
cout<<" NC "<<in1->N<<" NR "<<in1->I[0]<<"\n";
fstream f_in(argv[2],ios::in);f_in>>tmp>>NumX>>tmp>>Misf;f_in.close();
DataRegister("TDataF",out);
int NC=in1->N,NR=in->I[0];
int *I=new int[in1->N];for (int k=0;k<NC;k++) I[k]=NR;
out->SetDim(NC,I);movmem(in->D[0],out->D[0],sizeof(out->D[0][0])*NR);
cout<<" NC "<<NC<<" NR "<<NR<<"\n";
CurveSpline *S=new CurveSpline[NC-1];
int n=NumX;
Mis=Misf;
// TData<double> **S=new TData<double>*[NC-1];
for (k=1;k<NC;k++) {S[k-1].Generate(NumX,Misf,0,*in1,0,k);NumX=n;Misf=Mis;}
cout<<" Constructed\n";
cout<<" coreleft "<<coreleft()<<"\n";
// for (k=1;k<NR;k++) {cout<<out->D[0][k]<<"\n";}
for (k=1;k<NC;k++) {S[k-1].Evaluate(*out,0,k);}
OutputTDataF(f_out,*out);
delete in;delete in1;delete out;delete I;
// for (k=0;k<NC-1;k++) delete S[k];
delete S;
f_out.close();
cout<<" coreleft "<<coreleft()<<"\n";
};
void setleftcol(void)
/* Sets the value of leftcol based on the value of rightcol */
{
int total = 80, col = 0;
while ((total >= LEFTMARGIN) && (rightcol - col >= 0))
{
colstart[SCREENCOLS - col - 1] = total - colwidth[rightcol - col];
total -= colwidth[rightcol - col++];
}
if (total >= LEFTMARGIN)
col++;
movmem(&colstart[SCREENCOLS - col + 1], colstart, col - 1);
leftcol = rightcol - col + 2;
total = colstart[0] - LEFTMARGIN;
if (total != 0)
{
for (col = leftcol; col <= rightcol; col++)
colstart[col - leftcol] -= total;
}
printcol();
} /* setleftcol */
void valuestring(CELLPTR cellptr, double value, char *vstring, int col,
int fvalue, int *color, int formatting)
/* Sets the string representation of a value */
{
char s[81];
char *fstring;
int width, pos;
if (value == HUGE_VAL)
{
strcpy(vstring, MSGERROR);
*color = ERRORCOLOR;
}
else
{
if (formatting)
{
sprintf(vstring, "%1.*f", fvalue & 15, cellptr->v.value);
if (fvalue & COMMAS)
{
pos = strcspn(vstring, ".");
while (pos > 3)
{
pos -= 3;
if (vstring[pos - 1] != '-')
{
movmem(&vstring[pos], &vstring[pos + 1], strlen(vstring) - pos + 1);
vstring[pos] = ',';
}
}
}
if (fvalue & DOLLAR)
{
if (vstring[0] == '-')
{
fstring = " $";
width = colwidth[col] - 2;
}
else
{
fstring = " $ ";
width = colwidth[col] - 3;
}
}
else
{
fstring = "";
width = colwidth[col];
}
strcpy(s, vstring);
if (fvalue & RJUSTIFY)
{
if (strlen(vstring) > width)
vstring[width] = 0;
else
sprintf(vstring, "%*s", width, s);
}
else
sprintf(vstring, "%-*s", width, s);
movmem(vstring, &vstring[strlen(fstring)], strlen(vstring) + 1);
strncpy(vstring, fstring, strlen(fstring));
}
else
sprintf(vstring, "%.*f", MAXPLACES, value);
*color = VALUECOLOR;
}
} /* valuestring */
/*
* Unpack a DTYPA RR (address record)
*/
static void typea_unpacker( void *data, /* where to put IP */
struct rrpart *rrp, struct useek *qp )
{
qp = qp;
movmem(rrp->rdata,data,4); /* save IP # */
}
word FSFormat( byte Device, byte PartyID, byte Type )
/*
- if DataParty==FALSE => swap party is created
Format:
- check BR
- check size ( minimal/maximal size for file system )
- create system info file in mem
- nr of groups on volume
- nr of sectors on volume
- nr of sectors in last group ( not whole )
- striping table
- create groups
- fill groups bitmaps
- create and fill group info system file in mem
- found bad blocks
- write report to bad blocks system file in mem
- create ROOT directory
- create dir ->file system files.system<-
- create subdir ->transactions.system<- for transactions
- create file ->logfiles list.system<- list of logfiles
- create file ->STRIPING TABLE.system<- ( flush it to disk )
- create file ->GROUP info.system<- ( flush it to disk )
- create file ->BAD SECs.system<- ( flush it to disk )
- create file ->BAD GROUPSs.system<- ( flush it to disk ) has bad bitmap sectors
*/
{
MasterBootRecord BR;
dword GroupStatisticSectors;
// load partition boot record
#ifdef DEBUG
printf("\n\n Party %d on device 0x%x will be FORMATED...", PartyID, Device );
printf("\n Loading BR...");
#endif
if( LoadBoot( Device, PartyID, &BR ) )
{
#ifdef DEBUG
printf("\n Error reading BR..." );
#endif
return ERR_FS_FATAL_ERROR;
}
else
{
#ifdef DEBUG
printf(" OK..." );
#endif
}
// fill format specific structures ( use them for something useful... )
BR.BPB.CATCopies =0; // filled with format - not used
BR.BPB.RootRecords =0; // filled with format - not used
BR.BPB.SizeOfCat =0; // filled with format - not used
BR.BPB.RootFNODEAddr =0; // filled with format
// BR.BPB.NrOfGroups =0; // init in call CreateNrOfGroups
BR.BPB.DirtyFlag =PARTY_IS_CLEAN;
// fill magic word
// far copy
byte i,
MagicData[]={RFS_MAGIC_WORD_DATA_PARTY},
MagicSwap[]={RFS_MAGIC_WORD_SWAP_PARTY};
if( Type==RFS_DATA )
{
for(i=0; i<=7; i++ ) BR.OSID.ID[i]=MagicData[i];
}
else
{
for(i=0; i<=7; i++ ) BR.OSID.ID[i]=MagicSwap[i];
}
// create groups
TheSecondBoot SecondBoot; // statistic of party => the second boot
SecondBoot.MagicBegin= SecondBoot.MagicEnd = 0xCDAB;
// PartyStat.FreeSecs initialized in CreateNrOfGroups
SecondBoot.Label[0] =0;
strcpy( SecondBoot.Label, "Party label not used!" );
// - BR.BPB.HiddenSectors == first logical sector of party
// - use NrOfGroups to change nr. of reserved sectors
// ( The second boot + group statistic added here )
// change hidden sectors
BR.BPB.ReservedSectors += 1u; // reserving sector for the second boot
CreateNrOfGroups(
Device,
(dword)((dword)BR.BPB.HiddenSectors+(dword)BR.BPB.ReservedSectors),
(dword)((dword)BR.BPB.TotalSectors-(dword)BR.BPB.ReservedSectors),
BR.BPB.NrOfGroups,
SecondBoot.FreeSecs, // free space on party in secs
GroupStatisticSectors // nr of secs with group statistic
);
SecondBoot.StatSectors=GroupStatisticSectors;
// reserving sectors for group statistic
BR.BPB.ReservedSectors += (word)GroupStatisticSectors;
// nr. of sectors used for group statistic,
// each groups needs two bytes:
// in this is nr of free sectors in group
// copy BPB
movmem((const void *)&(BR.BPB), (void *)&(SecondBoot.BPB), sizeof(BIOSParameterBlock) );
// Write The Second Boot
// HiddenSectors == first logical sector of party because of logic. address
if( WriteLogicalSector( Device,
BR.BPB.HiddenSectors+1lu,// stat is 2. sec in party
MK_FP( FP_SEG(&SecondBoot), FP_OFF(&SecondBoot) ) )
)
{
#ifdef SEE_ERROR
printf("\n Error writing The Second Boot..." );
#endif
}
#ifdef DEBUG
printf("\n Party STATISTIC saved:"
"\n Free : %lu sectors"
"\n it is : %lu bytes"
"\n Label : %s"
,
SecondBoot.FreeSecs,
SecondBoot.FreeSecs*512lu,
SecondBoot.Label );
#endif
if( SaveBoot( Device, PartyID, &BR ) )
{
#ifdef DEBUG
printf(" error writing MBR..." );
#endif
return ERR_FS_FATAL_ERROR;
}
Device&=0x0F;
// Creating of root dir here...
CreateRootDir( Device, PartyID, BR.BPB.RootFNODEAddr );
// copy BPB
movmem((const void *)&(BR.BPB), (void *)&(SecondBoot.BPB), sizeof(BIOSParameterBlock) );
if( SaveBoot( Device, PartyID, &BR ) )
{
#ifdef DEBUG
printf(" error writing MBR..." );
#endif
return ERR_FS_FATAL_ERROR;
}
// Write The Second Boot
if( WriteLogicalSector( Device,
BR.BPB.HiddenSectors+1lu,// stat is 2. sec in party
MK_FP( FP_SEG(&SecondBoot), FP_OFF(&SecondBoot) ) )
)
{
#ifdef SEE_ERROR
printf("\n Error writing The Second Boot..." );
#endif
}
#ifdef DEBUG
printf("\n Format results:" );
LoadBoot( Device, PartyID, &BR );
printf("\n Format OK..." );
#endif
return ERR_FS_NO_ERROR;
}
/*-----------------------------------------------
| |
| getdata()/0 |
| |
| This function reads the 1D or 2D data in |
| form disk, manipulates it appropriately, |
| and moves the ReRe component to the memory |
| allocated for the phasefile data. |
| |
+----------------------------------------------*/
static int getdata()
{
char dsplymes[20], /* display mode label */
dmg1[5];
int npf1=0, /* number of points along F1 */
npf2=0, /* number of points along F2 */
i,
r,
found,
f1phase,
f2phase,
quad2,
quad4,
complex_1D=0,
norm_av,
norm_dir,
norm_phase,
norm_phaseangle,
norm_dbm,
rev_av=0,
rev_dir=0,
rev_phase=0,
rev_phaseangle=0,
nplinear,
npblock;
float *f1phasevec=NULL, /* F1 phasing vector */
*f2phasevec=NULL; /* F2 phasing vector */
double rp_norm,
lp_norm;
double rp_rev,
lp_rev;
dpointers datablock;
hycmplxhead *tmpblkhead;
/********************************************
* Get pointer to data in specified block. *
********************************************/
if ( (r = D_getbuf(D_DATAFILE, nblocks, c_buffer, &datablock)) )
{
D_error(r);
return(ERROR);
}
else if (checkdata(datablock.head))
{
return(ERROR);
}
/**********************
* Setup for 2D data *
**********************/
quad2 = quad4 = FALSE;
f1phase = f2phase = FALSE;
if (d2flag)
{
/************************************
* Set the flags for the number of *
* quadrants. *
************************************/
quad4 = (datahead.status & S_HYPERCOMPLEX);
if (!quad4)
quad2 = (datahead.status & S_COMPLEX);
/********************************************
* Precalculate phasing vectors for the F1 *
* and F2 dimensions if necessary. *
********************************************/
nplinear = pointsperspec;
npblock = specperblock * nblocks;
if (quad4)
{
npblock *= 2;
nplinear /= 2;
}
if (revflag)
{
npf1 = nplinear;
npf2 = npblock;
}
else
{
npf2 = nplinear;
npf1 = npblock;
}
f1phasevec = NULL; /* initialize pointer */
f2phasevec = NULL; /* initialize pointer */
/**********************************************
* If a phase-sensitive display is requested *
* along F1, precalculate the F1 phasing *
* vector. *
**********************************************/
rev_dir = get_direction(REVDIR);
get_phase_pars(rev_dir,&rp_rev,&lp_rev);
rev_phase = get_phase_mode(rev_dir);
rev_phaseangle = get_phaseangle_mode(rev_dir);
rev_av = get_av_mode(rev_dir);
f1phase = ( ((rev_phase && nonzerophase(rp_rev, lp_rev)) || rev_phaseangle) &&
(quad2 || quad4) &&
get_axis_freq(rev_dir) );
if (f1phase)
{
f1phasevec = (float *) (allocateWithId( (unsigned) (sizeof(float)
* npf1), "getdata" ));
if (f1phasevec == NULL)
{
Werrprintf("Unable to allocate memory for F1 phase buffer");
return(ERROR);
}
else
{
phasefunc(f1phasevec, npf1/2, lp_rev, rp_rev);
}
}
/**********************************************
* If a phase-sensitive display is requested *
* along F2, precalculate the F2 phasing *
* vector. *
**********************************************/
norm_dir = get_direction(NORMDIR);
get_phase_pars(norm_dir,&rp_norm,&lp_norm);
norm_phase = get_phase_mode(norm_dir);
norm_phaseangle = get_phaseangle_mode(norm_dir);
norm_av = get_av_mode(norm_dir);
norm_dbm = get_dbm_mode(norm_dir); /* may not be active?? */
f2phase = ( (norm_phase || norm_phaseangle) && quad4 && nonzerophase(rp_norm, lp_norm) );
/* (quad4 || quad2)?? (quad4) only?? */
if (f2phase)
{
f2phasevec = (float *) (allocateWithId( (unsigned) (sizeof(float)
* npf2), "getdata" ));
if (f2phasevec == NULL)
{
Werrprintf("Unable to allocate memory for F2 phase buffer");
if (f1phase)
releaseAllWithId("getdata");
return(ERROR);
}
else
{
phasefunc(f2phasevec, npf2/2, lp_norm, rp_norm);
}
}
}
else
{
complex_1D = (datablock.head->status & NP_CMPLX);
norm_dir = HORIZ;
norm_phase = get_phase_mode(norm_dir);
norm_phaseangle = get_phaseangle_mode(norm_dir);
norm_av = get_av_mode(norm_dir);
norm_dbm = get_dbm_mode(norm_dir); /* may not be active 2 */
}
/*************************************
* Readjust "npf1" and "npf2" to be *
* per block. *
*************************************/
if (d2flag)
{
if (revflag)
{
npf2 /= nblocks;
}
else
{
npf1 /= nblocks;
}
}
/**********************************
* Construct display mode label. *
**********************************/
strcpy(dsplymes, ""); /* initialization of string */
if ( d2flag && (quad2 || quad4) )
{
char charval;
char tmp[10];
get_display_label(rev_dir,&charval);
if (rev_phase)
{
sprintf(tmp, "PH%c ",charval);
}
else if (rev_av)
{
sprintf(tmp, "AV%c ",charval);
}
else if (rev_phaseangle)
{
sprintf(tmp, "PA%c ",charval);
}
else
{
sprintf(tmp, "PW%c ",charval);
}
strcpy(dsplymes, tmp);
}
if ( (d2flag && quad4) || ((!d2flag) && complex_1D) )
{
char charval;
char tmp[10];
get_display_label(norm_dir,&charval);
if (charval == '\0')
charval = ' ';
if (norm_phase)
{
sprintf(tmp, "PH%c",charval);
}
else if (norm_av)
{
sprintf(tmp, "AV%c",charval);
}
else if (norm_phaseangle)
{
sprintf(tmp, "PA%c",charval);
}
else
{
sprintf(tmp, "PW%c",charval);
}
strcat(dsplymes, tmp);
}
disp_status(dsplymes);
/*************************************************
* Manipulate data depending upon the number of *
* 2D data quadrants and the desired mode of *
* display. *
*************************************************/
if (d2flag)
{
if (quad4)
{
/***********************************
* HYPERCOMPLEX 2D spectral data: *
* F2 phase-sensitive display *
***********************************/
if (norm_phase)
{
if (rev_phase)
{
/*****************************
* phase for ReRe component *
*****************************/
if (f1phase && f2phase)
{
blockphase4(datablock.data, c_block.data, f1phasevec,
f2phasevec, nblocks, c_buffer, npf1/2, npf2/2);
}
else if (f1phase)
{
blockphase2(datablock.data, c_block.data, f1phasevec,
nblocks, c_buffer, npf1/2, npf2/2, HYPERCOMPLEX,
COMPLEX, TRUE, FALSE);
}
else if (f2phase)
{
blockphase2(datablock.data, c_block.data, f2phasevec,
nblocks, c_buffer, npf1/2, npf2/2, HYPERCOMPLEX,
REAL, FALSE, FALSE);
}
else
{
movmem((char *)datablock.data, (char *)c_block.data,
(npf1*npf2*sizeof(float))/4, HYPERCOMPLEX,
4);
}
}
else
{
if (f2phase)
{
/***************************
* rotate ReRe <---> ReIm *
* rotate ImRe <---> ImIm *
***************************/
if (rev_av)
{
/********************************
* S = sqrt(ReRe**2 + ImRe**2) *
********************************/
blockphsabs4(datablock.data, c_block.data, f2phasevec,
nblocks, c_buffer, npf1/2, npf2/2, REAL, FALSE);
}
else if (rev_phaseangle)
{
blockphaseangle2(datablock.data, c_block.data, f1phasevec,
nblocks, c_buffer, npf1/2, npf2/2, HYPERCOMPLEX,
COMPLEX, TRUE, FALSE);
}
else
{
/**************************
* S = ReRe**2 + ImRe**2 *
**************************/
blockphspwr4(datablock.data, c_block.data, f2phasevec,
nblocks, c_buffer, npf1/2, npf2/2, REAL, FALSE);
}
}
else if (rev_av) /* no F2 phasing required */
{
/********************************
* S = sqrt(ReRe**2 + ImRe**2) *
********************************/
absval2(datablock.data, c_block.data, (npf1*npf2)/4,
HYPERCOMPLEX, COMPLEX, REAL, FALSE);
}
/* else if (rev_phaseangle) {} */
else /* no F2 phasing required */
{
/**************************
* S = ReRe**2 + ImRe**2 *
**************************/
pwrval2(datablock.data, c_block.data, (npf1*npf2)/4,
HYPERCOMPLEX, COMPLEX, REAL, FALSE);
}
}
}
/***********************************
* HYPERCOMPLEX 2D spectral data: *
* F2 absolute-value display *
***********************************/
else if (norm_av)
{
if (rev_phase)
{
if (f1phase)
{
/********************************
* rotate ReRe <---> ImRe *
* rotate ReIm <---> ImIm *
* S = sqrt(ReRe**2 + ReIm**2) *
********************************/
blockphsabs4(datablock.data, c_block.data, f1phasevec,
nblocks, c_buffer, npf1/2, npf2/2, COMPLEX, TRUE);
}
else
{
/********************************
* S = sqrt(ReRe**2 + ReIm**2) *
********************************/
absval2(datablock.data, c_block.data, (npf1*npf2)/4,
HYPERCOMPLEX, REAL, REAL, FALSE);
}
}
else if (rev_av)
{
/****************************************************
* S = sqrt(ReRe**2 + ReIm**2 + ImRe**2 + ImIm**2) *
****************************************************/
absval4(datablock.data, c_block.data, npf1*npf2/4);
}
/* else if (rev_phaseangle) {} */
else
{
/****************************
* S1 = ReRe**2 + ImRe**2 *
* S2 = ReIm**2 + ImIm**2 *
* S = sqrt(S1**2 + S2**2) *
****************************/
blockpwrabs(datablock.data, c_block.data, (npf1*npf2)/4,
COMPLEX);
}
}
/***********************************
* HYPERCOMPLEX 2D spectral data: *
* F2 phaseangle display *
***********************************/
else if (norm_phaseangle)
{
Werrprintf("Cannot perform hypercomplex phaseangle");
return(ERROR);
}
/***********************************
* HYPERCOMPLEX 2D spectral data: *
* F2 power display *
***********************************/
else
{
if (rev_phase)
{
if (f1phase)
{
/***************************
* rotate ReRe <---> ImRe *
* rotate ReIm <---> ImIm *
* S = ReRe**2 + ReIm**2 *
***************************/
blockphspwr4(datablock.data, c_block.data, f1phasevec,
nblocks, c_buffer, npf1/2, npf2/2, COMPLEX, TRUE);
}
else
{
/**************************
* S = ReRe**2 + ReIm**2 *
**************************/
pwrval2(datablock.data, c_block.data, (npf1*npf2)/4,
HYPERCOMPLEX, REAL, REAL, FALSE);
}
}
else if (rev_av)
{
/****************************
* S1 = ReRe**2 + ReIm**2 *
* S2 = ImRe**2 + ImIm**2 *
* S = sqrt(S1**2 + S2**2) *
****************************/
blockpwrabs(datablock.data, c_block.data, (npf1*npf2)/4,
REAL);
}
/* else if (rev_phaseangle) {} */
else
{
/**********************************************
* S = ReRe**2 + ReIm**2 + ImRe**2 + ImIm**2 *
* THIS IS NOT QUITE RIGHT! *
**********************************************/
pwrval4(datablock.data, c_block.data, npf1*npf2/4);
}
}
/**********************************************
* Set the F1 phase constants into the block *
* header of the phasefile data. *
**********************************************/
if (rev_phase || rev_phaseangle)
{
c_block.head->lpval = lp_rev;
c_block.head->rpval = rp_rev;
}
else
{
c_block.head->lpval = 0.0;
c_block.head->rpval = 0.0;
}
/***************************************************
* Locate the block header for the "hypercomplex" *
* information. Then set the F2 phase constants *
* into the block header of the phasefile data. *
***************************************************/
i = 0;
found = FALSE;
while (!found)
{
if ( (~(datablock.head + i)->status) & MORE_BLOCKS )
{
Werrprintf("Block headers inconsistent with hypercomplex data");
if (f1phase || f2phase)
releaseAllWithId("getdata");
return(ERROR);
}
i += 1;
found = ( (datablock.head + i)->status & U_HYPERCOMPLEX );
}
tmpblkhead = (hycmplxhead *) (c_block.head + i);
if (norm_phase)
{
tmpblkhead->lpval1 = lp_norm;
tmpblkhead->rpval1 = rp_norm;
}
else
{
tmpblkhead->lpval1 = 0.0;
tmpblkhead->rpval1 = 0.0;
}
}
else if (quad2)
{
/*******************************
* COMPLEX 2D spectral data: *
* F1 display selection *
*******************************/
if (rev_phase)
{
/***************************
* rotate ReRe <---> ImRe *
***************************/
if (f1phase)
{
blockphase2(datablock.data, c_block.data, f1phasevec,
nblocks, c_buffer, npf1/2, npf2, COMPLEX, 1,
TRUE, FALSE);
}
else
{
movmem((char *)datablock.data, (char *)c_block.data,
(npf1*npf2*sizeof(float))/2, COMPLEX, 4);
}
}
else if (rev_phaseangle)
{
if (f1phase)
{
blockphaseangle2(datablock.data, c_block.data, f1phasevec,
nblocks, c_buffer, npf1/2, npf2, COMPLEX, 1,
TRUE, FALSE);
}
else
{
movmem((char *)datablock.data, (char *)c_block.data,
(npf1*npf2*sizeof(float))/2, COMPLEX, 4);
}
}
else if (rev_av)
{
/********************************
* S = sqrt(ReRe**2 + ImRe**2) *
********************************/
absval2(datablock.data, c_block.data, (npf1*npf2)/2,
COMPLEX, 1, 1, FALSE);
}
else
{
/**************************
* S = ReRe**2 + ImRe**2 *
**************************/
pwrval2(datablock.data, c_block.data, (npf1*npf2)/2,
COMPLEX, 1, 1, FALSE);
}
if (rev_phase || rev_phaseangle)
{
c_block.head->lpval = lp_rev;
c_block.head->rpval = rp_rev;
}
else
{
c_block.head->lpval = 0.0;
c_block.head->rpval = 0.0;
}
}
else
{
/***************************
* REAL 2D spectral data *
***************************/
movmem((char *)datablock.data, (char *)c_block.data,
npf1*npf2*sizeof(float), REAL, 4);
c_block.head->lpval = 0.0;
c_block.head->rpval = 0.0;
}
}
/**********************
* Setup for 1D data *
**********************/
else
{
if(bph()>0 && complex_1D && (norm_phase || norm_phaseangle)) {
// don't use lp, rp, because block is individually phased.
c_block.head->lpval=getBph1(c_buffer);
c_block.head->rpval=getBph0(c_buffer);
if (norm_phase)
{
phase2(datablock.data, c_block.data, fn/2, c_block.head->lpval, c_block.head->rpval);
}
else if (norm_phaseangle)
{
phaseangle2(datablock.data, c_block.data, fn/2, COMPLEX,
1, 1, FALSE, c_block.head->lpval, c_block.head->rpval);
}
P_setreal(CURRENT,"bph1",c_block.head->lpval,0);
P_setreal(CURRENT,"bph0",c_block.head->rpval,0);
} else {
c_block.head->lpval = 0.0;
c_block.head->rpval = 0.0;
if (complex_1D)
{
if (norm_phase)
{
phase2(datablock.data, c_block.data, fn/2, lp, rp);
c_block.head->lpval = lp;
c_block.head->rpval = rp;
}
else if (norm_phaseangle)
{
phaseangle2(datablock.data, c_block.data, fn/2, COMPLEX,
1, 1, FALSE, lp, rp);
c_block.head->lpval = lp;
c_block.head->rpval = rp;
}
else if (norm_av)
{
absval2(datablock.data, c_block.data, fn/2, COMPLEX,
1, 1, FALSE);
}
else if (norm_dbm)
{
dbmval2(datablock.data, c_block.data, fn/2, COMPLEX,
1, 1, FALSE);
}
else
{
pwrval2(datablock.data, c_block.data, fn/2, COMPLEX,
1, 1, FALSE);
}
}
else
{
if (datablock.head->status & S_COMPLEX)
{
movmem((char *)datablock.data, (char *)c_block.data,
(fn/2)*sizeof(float), COMPLEX, 4);
}
else
{
movmem((char *)datablock.data, (char *)c_block.data,
(fn/2)*sizeof(float), REAL, 4);
}
}
}
}
/*************************************
* Set status word for block header *
* of phasefile. *
*************************************/
c_block.head->status = (S_DATA|S_SPEC|S_FLOAT);
/***********************************
* Set mode word for block header *
* of phasefile. *
***********************************/
c_block.head->mode = get_mode(HORIZ);
if (d2flag)
c_block.head->mode |= get_mode(VERT);
/***************************************
* Set additional words in main block *
* header of phasefile. *
***************************************/
c_block.head->scale = 0;
c_block.head->ctcount = 0;
c_block.head->index = (short)c_buffer;
c_block.head->lvl = 0.0;
c_block.head->tlt = 0.0;
/************************************************
* Set status word in previous block header of *
* phasefile to indicate the presence of a *
* following block header. *
************************************************/
if (d2flag)
{
i = 0;
while ((datablock.head + i)->status & MORE_BLOCKS)
{
(c_block.head + i)->status |= MORE_BLOCKS;
i += 1;
if ((datablock.head + i)->status & U_HYPERCOMPLEX)
(c_block.head + i)->status |= U_HYPERCOMPLEX;
}
}
/******************************************
* Release this DATAFILE buffer with the *
* data handler routines. *
******************************************/
if ( (r = D_release(D_DATAFILE, c_buffer)) )
{
D_error(r);
if (f1phase || f2phase)
releaseAllWithId("getdata");
return(ERROR);
}
if (P_copyvar(CURRENT, PROCESSED, "dmg", "dmg"))
{
Werrprintf("dmg: cannot copy from 'current' to 'processed' tree\n");
if (f1phase || f2phase)
releaseAllWithId("getdata");
return(ERROR);
}
if (d2flag)
{
if (!P_getstring(CURRENT, "dmg1", dmg1, 1, 5))
{
if (P_copyvar(CURRENT, PROCESSED, "dmg1", "dmg1"))
{
Werrprintf("dmg1: cannot copy from 'current' to 'processed' tree");
if (f1phase || f2phase)
releaseAllWithId("getdata");
return(ERROR);
}
}
}
if (f1phase || f2phase)
releaseAllWithId("getdata");
if (!Bnmr)
disp_status(" ");
return(COMPLETE);
}
/*************************************
fiddle()
**************************************/
int fiddle(int argc, char *argv[], int retc, char *retv[])
{
int pwr,cblock,res,dc_correct=TRUE;
register int i,ntval;
dpointers inblock;
float a,b,c,d,denom;
int ocount;
/* initialization bits */
if (i_fiddle(argc,argv))
ABORT;
dc_correct=dccorr;
pwr = fnpower(fn0);
max=0.0;
cfcount=0;
count=0;
firstrefint=0.0;
phasetweek=0.0;
degtorad=3.141592654/180.0;
ocount=0;
ntval = 1;
if (!P_getreal(PROCESSED, "nt", &tmp, 1))
{
ntval = (int) (tmp + 0.5);
if (ntval < 1)
ntval = 1;
}
disp_status("IN3 ");
/* check range of transforms */
if (startno>=fidhead.nblocks) startno=fidhead.nblocks-1;
if (startno<0) {
startno=0;
finishno=fidhead.nblocks;
stepno=1;
}
if (finishno>fidhead.nblocks) finishno=fidhead.nblocks;
if (stepno==0) stepno=1;
/* setup destination fidfile and/or correction function file if requested
*/
if (writefg) setupwritefile();
if (writecfflg) setupwritecf();
/* start of main loop */
incno=0;
t1=0;
rp0=rp;
for (cblock = startno; cblock < finishno; cblock+=stepno)
{
if ( (res = D_getbuf(D_DATAFILE, fidhead.nblocks, cblock, &inblock)) )
{
D_error(res);
freall(TRUE);
}
if ( (inblock.head->status & (S_DATA|S_SPEC|S_FLOAT|S_COMPLEX)) ==
(S_DATA|S_SPEC|S_FLOAT|S_COMPLEX) )
{
disp_index(cblock+1);
incno+=1;
if (verbose) Wscrprintf("Increment no. %d \n",incno);
if (!aphflg) incrementrp();
inp = (float *)inblock.data;
/* DEBUGGING ONLY
if (verbose) Wscrprintf("Real part of 1st point of original fid
%f \n",
inp[0]);
if (verbose) Wscrprintf("Imag part of 1st point of original fid
%f \n",
inp[1]);
*/
/* dc (not normally used!)
if (dc_correct)
{
disp_status("DC ");
cmplx_dc(inp, &lvl_re, &lvl_im, &tlt_re, &tlt_im, np0/2,
CMPLX_DC);
vvrramp(inp, 2, inp, 2, lvl_re, tlt_re, np0/2);
vvrramp(inp+1, 2, inp+1, 2, lvl_im, tlt_im, np0/2);
} */
/* phase correct spectrum */
finalph=0.0;
rotate2(inp,np0/2,lp,rp);
if (aphflg)
{
faph(inp,leftpos,rightpos,&finalph);
rotate2(inp,np0/2,0.0,finalph);
}
/* if baseline then zero imag. */
if (baseline||hilbert) fiddle_zeroimag();
/* move first to data1, ready for ift, n.b. fn0==np0 */
transpmove(inp,data1);
/* do zeroing for reference region */
if (solvent) solventextract();
else
{
for (i=0;i<leftpos;i++)
{
inp[i]=0.0;
}
for (i=rightpos+2;i<np0;i++)
{
inp[i]=0.0;
}
if (ldcflag) baseline_correct(inp,leftpos,rightpos);
if (extrap) extrapolate();
} /* !solvent */
transpmove(inp,data2);
/* now do the ift's */
if (!noift)
{
disp_status("IFT1 ");
fft(data1,fn0/2,pwr,0,COMPLEX,COMPLEX,1.0,FTNORM/ntval,np0/2);
disp_status("IFT2 ");
fft(data2,fn0/2,pwr,0,COMPLEX,COMPLEX,1.0,FTNORM/ntval,np0/2);
}
if (makereffg) makeideal();
/* need to weight data3 to create ideal fid */
if (makereffg&&!noift)
{
disp_status("WT ");
weightfid(wtfunc,data3,np0w/2,FALSE,COMPLEX);
}
if (stopflag<1||stopflag>3)
{
/* DEBUGGING ONLY
if (verbose) Wscrprintf("Real part of 1st point of
original fid %f \n",
data1[0]);
if (verbose) Wscrprintf("Imag part of 1st point of
original fid %f \n",
data1[1]);
*/
/* divide (3) by (2) */
disp_status("DIV ");
for (i=0;i<npi;i+=2)
{
a=data3[i];
b=data3[i+1];
c=data2[i];
d=data2[i+1];
denom=c*c+d*d;
data2[i]=(a*c+b*d)/denom;
data2[i+1]=(b*c-a*d)/denom;
}
if (writecfflg) writeoutcf();
if (readcfflg) readincf();
/* and multiply by (1) */
/* DEBUGGING ONLY
if (verbose) Wscrprintf("Real part of 1st point of
correction function %f \n",
data2[0]);
if (verbose) Wscrprintf("Imag part of 1st point of
correction function %f \n",
data2[1]);
*/
disp_status("MUL ");
if (!corfunc)
{
for (i=0;i<npi;i+=2)
{
a=data2[i];
b=data2[i+1];
c=data1[i];
d=data1[i+1];
inp[i]=(a*c-b*d);
inp[i+1]=(b*c+a*d);
}
}
/* DEBUGGING ONLY
if (verbose) Wscrprintf("Real part of 1st point of
corrected fid %f \n",
inp[0]);
if (verbose) Wscrprintf("Imag part of 1st point of
corrected fid %f \n",
inp[1]);
*/
/* Halve first point of corrected fid */
/* hang about, does this do anything??? */
if (halffg) /* default true */
{
data1[0]=0.5*(data1[0]);
data1[1]=0.5*(data1[1]);
}
if (npi<np0)
for (i=npi;i<np0;i++)
inp[i]=0.0;
} /* stopflag not 1 - 3 */
if (firstfg&&!nosub)
movmem((char *)inp,(char *)data4,sizeof(float)*np0,1,4);
if (secondfg&&!nosub)
{
disp_status("SUB ");
submem(inp,data4,np0);
if (invert) invertmem(inp,np0);
}
/* inp contains result fid - write out and/or FT! */
if (writefg&&!firstfg) writeoutresult();
if (!noftflag)
{
disp_status("FT ");
fft(inp,fn0/2,pwr,0,COMPLEX,COMPLEX,-1.0,FTNORM/ct,np0/2);
}
/* move intermediate result for display if requested */
if (stopflag||corfunc)
{
disp_status("MOVE ");
switch (stopflag)
{
case 1:
p=data1;
break;
case 2:
p=data2;
break;
case 4:
p=data4;
break;
default:
p=data3;
break;
}
if (corfunc) p=data2;
if (difffg&&(stopflag<4))
{
if (firstfg) movmem((char *)p,(char
*)data4,sizeof(float)*np0,1,4);
if (!firstfg)
{
submem(p,data4,np0);
if (invert) invertmem(p,np0);
}
}
if (noift)
transpmove(p,inp);
else
movmem((char *)p,(char *)inp,sizeof(float)*np0,1,4);
}
/* re-phase back to rp,lp */
disp_status("PHASE ");
if (!(writefg&&!firstfg)) /* if not both writing and subsequent
fid */
{
rotate2(inp,np0/2,-lp,-rp);
}
else rotate2(inp,np0/2,-lp,0.0);
if (difffg)
{
secondfg=!secondfg;
firstfg=!firstfg;
}
if (udifffg)
{
secondfg=TRUE;
firstfg=FALSE;
}
if (secondfg||oflag)
makereffg=FALSE;
else makereffg=TRUE;
/* oflag increment */
if (oflag)
{
rp+=odat[ocount];
ocount++;
if (ocount>3) ocount=0;
}
/* release result */
if ( (res=D_markupdated(D_DATAFILE,cblock)) )
{
D_error(res);
disp_status(" ");
freall(TRUE);
}
if ( (res = D_release(D_DATAFILE, cblock)) )
{
D_error(res);
disp_status(" ");
freall(TRUE);
}
if (interuption) /* ? not fully working ? */
{
Werrprintf("Fiddle processing halted");
freall(TRUE);
ABORT;
}
if (flag2d)
{
if (altfg)
{
if ((incno % 2)==0) t1=t1+1/sw1;
}
else
{
t1=t1+1/sw1;
}
}
} /* end of if ( (inblock.head->status &c at start of main loop */
} /* end of main loop */
start_from_ft=TRUE;
releasevarlist();
appendvarlist("cr");
Wsetgraphicsdisplay("ds");
/* free memory */
freall(FALSE);
disp_status(" ");
disp_index(0);
RETURN;
}
//typedef double* FOOL;
int MAPGetDir(double *Param,double *MaxStep,MatrCl &DirMat,double ErrorMatr)
{
//cout<<" MAPGetDir Begin \n";
int Dimen=Param[0],DimExp=(*MAPVar).ExperPoint[0],Ret=1;
if ((Dimen>0) && (DimExp>0))
{
int k,k1;
int Iter;
VecCl TmpGr(DimExp),CurGr(DimExp);
VecCl HiGrad(Dimen);
MatrCl WMat1(Dimen),WMat2(Dimen);
double TmpHi,CurHi=True_Hi(Param);
//cout<<" Coreleft MAPDir "<<coreleft()<<"\n";
double *TmpPar=new double[Dimen+1];
double *NormDiag=new double[Dimen+1];
VecCl *GrDat=new VecCl[Dimen+1];
for (k=1;k<=Dimen;k++) GrDat[k].SetDim(DimExp);
True_Gr(Param,CurGr.Ptr);
// begining of calculation of d(hi)/dx[k] in HiGrad[k]
//cout<<" Coreleft 90 "<<coreleft()<<"\n";
for (k=1;k<=Dimen;k++)
{
if (fabs(MaxStep[k])<MathZer) cout<<" MAPGetDir MaxStep k "<<MaxStep[k]<<" "<<k<<"\n";
movmem(Param,TmpPar,sizeof(double)*(Dimen+1));
TmpPar[k]+=DERIVESTP*MaxStep[k];
True_Gr(TmpPar,TmpGr.Ptr);
for (k1=1;k1<=DimExp;k1++)
GrDat[k][k1]=(TmpGr[k1]-CurGr[k1])/(DERIVESTP*MaxStep[k]);
TmpHi=True_Hi(TmpPar);
HiGrad[k]=(CurHi-TmpHi)/(DERIVESTP*MaxStep[k]);
}
//cout<<" Hi Grad "<<HiGrad<<"Cur_Hi "<<CurHi<<"\nMax Step ";
// for (k=1;k<=Dimen;k++) cout<<MaxStep[k]<<" ";cout<<"\n";
//ChRead();
//
// end of calculation of d(hi)/dx[k] in HiGrad[k]}
//
//{ begining of calculation d(integral(dx[i]))/dx[k]=hmat[i,k]
// D'[k]=correl[k] }
for (k=1;k<=Dimen;k++)
{
for (k1=k;k1<=Dimen;k1++)
WMat1(k,k1)=Correl_Func(DimExp,GrDat[k].Ptr,GrDat[k1].Ptr);
if (WMat1(k,k)<MathZer)
{cout<<" Function does not depend from parameter "<<k<<". Exiting\n";
Ret=0;goto exi;
}
double d=sqrt(WMat1(k,k));
if (d<MathZer) cout<<" MAPGetDir sqrt(WMat1(k,k)) k "<<d<<" "<<k<<"\n";
NormDiag[k]=1/d;//sqrt(WMat1(k,k));
}
//cout<<" dxi/dxk \n"<<WMat1;
for ( k=1;k<=Dimen;k++)
{
for (k1=k;k1<=Dimen;k1++)
{
WMat1(k,k1)=WMat1(k,k1)*NormDiag[k]*NormDiag[k1];
WMat1(k1,k)=WMat1(k,k1);
}
}
//cout<<" dxi/dxk normalized\n"<<WMat1;
// fwritem(nomparam,addr(hmat),1,1);k0:=ermes('first converted',-1);
//{ end of calculation d(integral(dx[i]))/dx[k]=hmat[i,k]
// D'[k,k]=correl[k] }
//cout<<" Coreleft 129 "<<coreleft()<<"\n";
// if ((Err=Jacobi(WMat1,1000,ErrorMatr,TmpPar,WMat1,Iter))!=0)
// {cout<<" Cannot Calculate Jacobi. Error ="<<Err<<" \n";exit(1);}
if (!ReduceLQ(WMat1,WMat1,TmpPar,ErrorMatr))
{cout<<" Cannot Calculate ReduceLQ. \n";Ret=0;goto exi;}
//cout<<" Coreleft 132=129"<<coreleft()<<"\n";
//cout<<" Eigen Vectors\n"<<WMat1<<" Eigen Val \n";ChRead();
//for ( k=1;k<=Dimen;k++) cout<<TmpPar[k]<<" ";cout<<"\n";
// Transpon(WMat1); //Because ReduceLQ we have not to transpon
WMat2=WMat1;
//cout<<" Coreleft 137 "<<coreleft()<<"\n";
//cout<<"Inverse ";
Inverse(WMat1);
//cout<<" O Key \n";
//cout<<" Coreleft 139=137"<<coreleft()<<"\n";
for ( k=1;k<=Dimen;k++)
{
for ( k1=1;k1<=Dimen;k1++)
{
double d=sqrt(fabs(TmpPar[k1]));
if (d<MathZer) cout<<" MAPGetDir sqrt(fabs(TmpPar[k1])) k1 "<<d<<" "<<k1<<"\n";
WMat2(k,k1)=WMat2(k,k1)/d;//sqrt(fabs(TmpPar[k1]));
}
}
WMat1=WMat2*WMat1;
//cout<< " Result Matr After Mull\n"<<WMat1;
for ( k=1;k<=Dimen;k++)
{
for ( k1=1;k1<=Dimen;k1++)
WMat1(k,k1)=WMat1(k,k1)*NormDiag[k];
}
//cout<<" MaxStep: ";
for ( k=1;k<=Dimen;k++)
{
double s=0;
for (int k1=1;k1<=Dimen;k1++) s+=HiGrad[k1]*WMat1(k1,k);
MaxStep[k]=s;
//cout<<MaxStep[k]<<" ";
}
//cout<<"\n";
//ChRead();
//cout<<" Coreleft 158=90 "<<coreleft()<<"\n";
DirMat=WMat1;
//cout<<" Coreleft 160 "<<coreleft()<<"\n";
//cout<< " Dir Matr \n"<<DirMat;
//cout<<"MaxStep ";for (k=1;k<=Dimen;k++) cout<<MaxStep[k]<<" ";cout<<"\n";
exi:
delete TmpPar;
delete NormDiag;
for ( k=0;k<=Dimen;k++) {delete GrDat[k].Ptr;GrDat[k].Ptr=NULL;}
delete GrDat;
//cout<< "End MAPGetDir\n";
//cout<<" Coreleft MAPDir "<<coreleft()<<"\n";
}
return Ret;
};
void fixformula(int col, int row, int action, int place)
/* Modifies a formula when its column or row designations need to change. */
{
char *colstart, *rowstart, s[6], newformula[MAXINPUT + 1],
*curpos = newformula;
int fcol, frow;
CELLPTR cellptr = cell[col][row];
double value;
strcpy(newformula, cellptr->v.f.formula);
while (*curpos != 0)
{
if (formulastart(&curpos, &fcol, &frow))
{
rowstart = curpos - rowwidth(frow);
colstart = rowstart - ((fcol > 25) ? 2 : 1);
switch (action)
{
case COLADD :
if (fcol < place)
break;
if (fcol == 25)
{
if (strlen(newformula) == MAXINPUT)
{
deletecell(col, row, NOUPDATE);
alloctext(col, row, newformula);
return;
}
movmem(colstart, colstart + 1, strlen(colstart) + 1);
}
colstring(fcol + 1, s);
movmem(s, colstart, strlen(s));
break;
case ROWADD :
if (frow < place)
break;
if (rowwidth(frow + 1) != rowwidth(frow))
{
if (strlen(newformula) == MAXINPUT)
{
deletecell(col, row, NOUPDATE);
alloctext(col, row, newformula);
return;
}
movmem(rowstart, rowstart + 1, strlen(rowstart) + 1);
}
sprintf(s, "%d", frow + 2);
movmem(s, rowstart, strlen(s));
break;
case COLDEL :
if (fcol <= place)
break;
if (fcol == 26)
movmem(colstart + 1, colstart, strlen(colstart) + 1);
colstring(fcol - 1, s);
movmem(s, colstart, strlen(s));
break;
case ROWDEL :
if (frow <= place)
break;
if (rowwidth(frow) != rowwidth(frow - 1))
movmem(rowstart + 1, rowstart, strlen(rowstart) + 1);
sprintf(s, "%d", frow);
movmem(s, rowstart, strlen(s));
break;
} /* switch */
}
else
curpos++;
}
if (strlen(newformula) != strlen(cellptr->v.f.formula))
{
value = cellptr->v.f.fvalue;
deletecell(col, row, NOUPDATE);
allocformula(col, row, newformula, value);
}
else
strcpy(cellptr->v.f.formula, newformula);
} /* fixformula */
int GetStringX(int echo, int maxchrs, char *defaultStr,
int (*isCharacterAccepted)(unsigned char),
int (*isStringAccepted)(char *, void *),
void *customData) {
int size = 0, pos=0, i, modified = FALSE, ch;
static int historycnt = -1;
radcnt = 0;
memset(inmat,0,1023);
if(defaultStr != NULL) {
size = pos = strlen(defaultStr);
SendStringNoBrk(defaultStr);
strcpy(inmat, defaultStr);
}
if(isCharacterAccepted == NULL) {
isCharacterAccepted = &IsPrintableCharacter;
}
for(;;) {
ch = GetChar();
if(ch == GETCHAR_LOGOUT) {
return 1;
}
if(ch == GETCHAR_RETURN) {
inmat[size] = '\0';
if(isStringAccepted == NULL || isStringAccepted(inmat, customData)) {
break;
}
}
else if(ch == GETCHAR_SOL) {
if(pos == 0) {
continue;
}
if(echo) {
SendStringNoBrk("\x1b\x5b%d\x44", pos);
}
pos = 0;
}
else if(ch == GETCHAR_EOL) {
if(pos == size) {
continue;
}
if(echo) {
SendStringNoBrk("\x1b\x5b%d\x43", size - pos);
}
pos = size;
}
else if(ch == GETCHAR_BACKSPACE) {
if(pos == 0) {
continue;
}
if(echo) {
if(Servermem->inne[nodnr].flaggor & SEKVENSANSI) {
SendStringNoBrk("\x1b\x5b\x44\x1b\x5b\x50",-1,0);
}
else {
SendStringNoBrk("\b \b",-1,0);
}
}
movmem(&inmat[pos], &inmat[pos - 1], size - pos);
pos--;
size--;
modified = TRUE;
}
else if(ch == GETCHAR_DELETE) {
if(pos == size) {
continue;
}
if(echo) {
SendStringNoBrk("\x1b\x5b\x50");
}
movmem(&inmat[pos + 1], &inmat[pos], size - pos);
size--;
modified = TRUE;
}
else if(ch == GETCHAR_DELETELINE) {
if(echo) {
if(pos > 0) {
SendStringNoBrk("\x1b\x5b%d\x44\x1b\x5b\x4a", pos);
} else {
SendStringNoBrk("\x1b\x5b\x4a");
}
}
memset(inmat, 0, 1023);
pos = size = 0;
}
else if(ch == GETCHAR_LEFT) {
if(pos == 0) {
continue;
}
if(echo) {
SendStringNoBrk("\x1b\x5b\x44",-1,0);
}
pos--;
} else if(ch == GETCHAR_RIGHT) {
if(pos == size) {
continue;
}
if(echo) {
SendStringNoBrk("\x1b\x5b\x43",-1,0);
}
pos++;
} else if(ch == GETCHAR_UP) {
if(!echo || historycnt >= 9 || commandhistory[historycnt + 1][0] == '\0') {
continue;
}
historycnt++;
strncpy(inmat, commandhistory[historycnt], maxchrs);
inmat[maxchrs] = '\0';
if(pos > 0) {
SendStringNoBrk("\x1b\x5b%d\x44\x1b\x5b\x4a%s", pos, inmat);
} else {
SendStringNoBrk("\x1b\x5b\x4a%s", inmat);
}
pos = size = strlen(inmat);
modified=FALSE;
} else if(ch == GETCHAR_DOWN) {
if(!echo) {
continue;
}
if(historycnt == 0 || historycnt == -1) {
historycnt = -1;
if(echo == 1) {
if(pos > 0) {
SendStringNoBrk("\x1b\x5b%d\x44\x1b\x5b\x4a",pos);
} else {
SendStringNoBrk("\x1b\x5b\x4a");
}
}
memset(inmat,0,1023);
pos=size=0;
continue;
}
if(historycnt == 0 || commandhistory[historycnt-1][0] == '\0') {
continue;
}
historycnt--;
strncpy(inmat, commandhistory[historycnt], maxchrs);
inmat[maxchrs] = '\0';
if(pos) {
SendStringNoBrk("\x1b\x5b%d\x44\x1b\x5b\x4a%s", pos, inmat);
} else {
SendStringNoBrk("\x1b\x5b\x4a%s", inmat);
}
pos = size = strlen(inmat);
modified=FALSE;
}
else if(isCharacterAccepted(ch)) {
if(size >= maxchrs) {
eka('\a');
continue;
}
if(echo) {
if(Servermem->inne[nodnr].flaggor & SEKVENSANSI) {
SendStringNoBrk("\x1b\x5b\x31\x40");
}
if(echo != STAREKO) {
if(ch == '+') {
SendStringNoBrk(" \b");
}
eka(ch);
} else {
eka('*');
}
}
movmem(&inmat[pos], &inmat[pos+1], size - pos);
inmat[pos++] = ch;
size++;
modified = TRUE;
}
}
inmat[size] = 0;
if(echo == STAREKO) {
if(pos != size) {
SendStringNoBrk("\x1b\x5b%d\x43", size - pos);
}
for(i = 0; i < size; i++) {
if(Servermem->inne[nodnr].flaggor & SEKVENSANSI) {
SendStringNoBrk("\x1b\x5b\x44\x1b\x5b\x50");
} else {
SendStringNoBrk("\b \b");
}
}
}
eka('\r');
if(inmat[0] && echo == 1 && modified) {
for(i = 9; i > 0; i--) {
strcpy(commandhistory[i], commandhistory[i-1]);
}
strncpy(commandhistory[0], inmat, 1023);
historycnt=-1;
}
if(historycnt > -1) {
historycnt--;
}
return 0;
}
word FSCreatMasterBoot( byte Device, word SectorSize, byte ClusterSectors )
{
MasterBootRecord MBR;
word Cylinders,
TrackSectors,
Surfaces;
#ifdef DEBUG
printf("\n\n Creating MBR of device 0x%x...", Device );
#endif
// fill MASTER BOOT RECORD
if( GetHardParameters( Device, Cylinders, TrackSectors, Surfaces ) )
{
#ifdef DEBUG
printf("\n Error: cann't read DEVICES.LST..." );
#endif
return ERR_FS_FATAL_ERROR;
}
MBR.BPB.SectorSize =SectorSize;
MBR.BPB.ClusterSectors =ClusterSectors;
MBR.BPB.ReservedSectors =TrackSectors; // MBR reserves one track!
MBR.BPB.CATCopies =0;
MBR.BPB.RootRecords =0;
MBR.BPB.OldSectors =0; // means not used
MBR.BPB.MediaDescr =0xF8;
MBR.BPB.SizeOfCat =0;
MBR.BPB.TrackSectors =TrackSectors;
MBR.BPB.Surfaces =Surfaces;
MBR.BPB.HiddenSectors =0;
MBR.BPB.TotalSectors =Surfaces*Cylinders*TrackSectors;
MBR.PartyTable.ID =0xAA55;
// no partitition in system now
MBR.PartyTable.Party[0].ActiveArea=0;
MBR.PartyTable.Party[0].BeginSurface=0;
MBR.PartyTable.Party[0].BeginCylinderAndSector=0;
MBR.PartyTable.Party[0].OSFlag=0;
MBR.PartyTable.Party[0].EndSurface=0;
MBR.PartyTable.Party[0].EndCylinderAndSector=0;
MBR.PartyTable.Party[0].EndCylinderAndSector=0;
MBR.PartyTable.Party[0].FirstSectorOff=0;
MBR.PartyTable.Party[0].SectorNum=0; // recognize, that party not exist
// null the REST
movmem( MBR.PartyTable.Party, MBR.PartyTable.Party+1, 16 );
movmem( MBR.PartyTable.Party, MBR.PartyTable.Party+2, 16 );
movmem( MBR.PartyTable.Party, MBR.PartyTable.Party+3, 16 );
if( SaveMasterBoot( Device, &MBR ) )
{
#ifdef DEBUG
printf(" error writing MBR..." );
#endif
return ERR_FS_FATAL_ERROR;
}
printf("\n MBR saved, OK...");
return ERR_FS_NO_ERROR;
}
/* move AB -> BA */
void transpmove(float *f, float *t)
{
movmem((char *)(f+np0/2),(char *)t,sizeof(float)*np0/2,1,4);
movmem((char *)f,(char *)(t+np0/2),sizeof(float)*np0/2,1,4);
}
/* Allows the user to edit a string with only certain characters allowed -
Returns TRUE if ESC was not pressed, FALSE is ESC was pressed. */
int editstring(char *s, char *legal, int maxlength)
{
int c, len = strlen(s), pos = len, insert = TRUE;
changecursor(insert);
do {
writef(1, 25, WHITE, 79, "%s", s);
gotoxy(pos + 1, 25);
switch(c = getkey()) {
case HOMEKEY :
pos = 0;
break;
case ENDKEY :
pos = len;
break;
case INSKEY :
insert = !insert;
changecursor(insert);
break;
case LEFTKEY :
if (pos > 0)
pos--;
break;
case RIGHTKEY :
if (pos < len)
pos++;
break;
case BS :
if (pos > 0) {
movmem(&s[pos], &s[pos - 1], len - pos + 1);
pos--;
len--;
}
break;
case DELKEY :
if (pos < len) {
movmem(&s[pos + 1], &s[pos], len - pos);
len--;
}
break;
case CR :
break;
case UPKEY :
break;
case DOWNKEY :
break;
case ESC :
break;
default :
if (((legal[0] == 0) || (strchr(legal, c) != NULL)) &&
((c >= ' ') && (c <= '~')) &&
(len < maxlength)) {
if (insert) {
memmove(&s[pos + 1], &s[pos], len - pos + 1);
len++;
}
else if (pos >= len)
len++;
s[pos++] = c;
}
break;
} /* switch */
s[len] = 0;
}
while ((c!=UPKEY)&&(c!=DOWNKEY)&&(c!=CR)&&(c!=ESC));
clearinput();
changecursor(FALSE);
setcursor(nocursor);
return(c != ESC);
} /* editstring */
int main( int argc, char *argv[] )
{
/* int i; */
int status = 0;
char *temp;
if (argc < 4 ) {
outs("SERTN host port program options\n\r");
exit(1);
}
sock_init();
if (!( host = resolve( argv[1] ))) {
outs( "Bad Host\n\r" );
exit(1);
}
if ( (temp = getenv( TCPTERM )) != NULL ) {
/* deal with strncpy limitation */
movmem( temp, termtype, sizeof( termtype ));
termtype[ sizeof(termtype) -1 ] = 0;
outs("TERMINAL EMULATION :");
outs( termtype );
outs("\n\r");
} else
strcpy(termtype, "UNKNOWN");
s = &socketdata;
if ( host == my_ip_addr ) {
outs("Incomming sessions not supported...\n\r");
sock_wait_established( s, 0, NULL, &status );
exit( -3 );
}
if (! tcp_open( s, 0, host, atoi( argv[2]), NULL )) {
#ifndef OLD
sock_recv_init( s, bigbuf, sizeof( bigbuf ), 0);
#endif OLD
outs( "Unable to open\n\r");
exit(1);
}
sock_wait_established( s, sock_delay, NULL, &status );
sock_mode( s, TCP_MODE_NAGLE );
sock_status = 1; /* allow interrupts */
/* move vectors */
moved_vectors = 1;
old8 = getvect( 0x08 );
old14 = getvect( 0x014 );
/*
setvect( 0x08, (void interrupt (*)())serial_t );
*/
setvect( 0x08, tcpport_tick );
setvect( 0x014,ourhandler); /* was serial_2 */
recvtimeout = set_ttimeout( 1 );
outs("Running...");
outs( argv[3] );
outs( "\n\r");
system( argv[ argc-1 ] );
outs("Done, now closing session\n\r");
setvect( 0x014, old14 );
setvect( 0x08, old8 );
moved_vectors = 0;
if ( s ) {
sock_close( s );
sock_wait_closed( s, sock_delay, NULL, &status );
}
sock_err:
switch (status) {
case 1 : outs("Done.\n\r");
break;
case -1: outs("Remote host reset connection.");
break;
}
if (moved_vectors) {
setvect( 0x014, old14 );
setvect( 0x08, old8 );
}
exit( (status)? 2 : 0);
return (0); /* not reached */
}
word LoadBoot( byte Device, byte PartyID, MasterBootRecord *pBR )
// in futute it should read all track ( MBR should be duplicated )
{
MasterBootRecord MBR;
if( LoadMasterBoot( Device, &MBR ) )
{
return ERR_FS_FATAL_ERROR;
}
// log. nr. of sector with BR: MBR.PartyTable.Party[PartyID].FirstSectorOff
// Record for this party not used
if( MBR.PartyTable.Party[PartyID-1].SectorNum == 0 )
return ERR_FS_NOT_USED;
if( ReadLogicalSector( Device,
MBR.PartyTable.Party[PartyID-1].FirstSectorOff,
MK_FP( FP_SEG(pBR), FP_OFF(pBR) ) )
)
return ERR_FS_FATAL_ERROR;
#ifdef DEBUG
printf(
"\n Loaded BR content:"
"\n OS ID %s"
"\n DirtyFlag %u"
"\n SectorSize %u"
"\n ClusterSectors %u"
"\n ReservedSectors %u"
"\n CATCopies %u"
"\n RootRecords %u"
"\n MediaDescr 0x%x"
"\n SizeOfCat %u"
"\n TrackSectors %u"
"\n Surfaces %u"
"\n HiddenSectors %lu"
"\n TotalSectors %lu"
"\n RootFNODEAddr %lu"
"\n NrOfGroups %lu"
,
pBR->OSID.ID,
pBR->BPB.DirtyFlag,
pBR->BPB.SectorSize,
pBR->BPB.ClusterSectors,
pBR->BPB.ReservedSectors,
pBR->BPB.CATCopies,
pBR->BPB.RootRecords,
pBR->BPB.MediaDescr,
pBR->BPB.SizeOfCat,
pBR->BPB.TrackSectors,
pBR->BPB.Surfaces,
pBR->BPB.HiddenSectors,
pBR->BPB.TotalSectors,
pBR->BPB.RootFNODEAddr,
pBR->BPB.NrOfGroups
);
#endif
// check if boot is valid
if( pBR->PartyTable.ID != 0xAA55 )
{
#ifdef SEE_ERROR
printf("\n Error: LoadBoot - magic 0xAA55 not found");
#endif
// recovery using The Second Boot Record
TheSecondBoot SecondBoot;
// read second boot
ReadLogicalSector( Device,
MBR.PartyTable.Party[PartyID-1].FirstSectorOff+1lu,
MK_FP( FP_SEG(&SecondBoot), FP_OFF(&SecondBoot) )
);
// copy BPB
movmem( (const void *)&(SecondBoot.BPB),
(void *)&(pBR->BPB),
sizeof(BIOSParameterBlock)
);
// copy OSID
movmem( (const void *)&(SecondBoot.OSID),
(void *)&(pBR->OSID),
sizeof(MBROSID)
);
// put magic
pBR->PartyTable.ID = 0xAA55;
SaveBoot( Device, PartyID, pBR );
#ifdef SEE_ERROR
printf(" => recovered... ");
#endif
}
return ERR_FS_NO_ERROR;
}
