bool String::IsNumeric() const
{
return (_Length > 0 &&
(ConvertToDouble() != 0.0 ||
_Data[0] == '0' ||
_Data[0] == '.' ||
_Data[0] == '-'));
}
double xlw::XlfOper4::AsDouble(int * pxlret) const
{
double d;
int xlret = ConvertToDouble(d);
if (pxlret)
*pxlret=xlret;
else
ThrowOnError(xlret);
return d;
};
double xlw::XlfOper4::AsDouble(const std::string& ErrorId, int * pxlret) const
{
double d;
int xlret = ConvertToDouble(d);
if (pxlret)
*pxlret=xlret;
else
ThrowOnError( xlret,"Conversion to double "+ErrorId);
return d;
};
void Interpreter::lfs(UGeckoInstruction _inst)
{
u32 uTemp = PowerPC::Read_U32(Helper_Get_EA(_inst));
if (!(PowerPC::ppcState.Exceptions & EXCEPTION_DSI))
{
u64 value = ConvertToDouble(uTemp);
riPS0(_inst.FD) = value;
riPS1(_inst.FD) = value;
}
}
void Interpreter::lfsux(UGeckoInstruction _inst)
{
u32 uAddress = Helper_Get_EA_UX(_inst);
u32 uTemp = PowerPC::Read_U32(uAddress);
if (!(PowerPC::ppcState.Exceptions & EXCEPTION_DSI))
{
u64 value = ConvertToDouble(uTemp);
riPS0(_inst.FD) = value;
riPS1(_inst.FD) = value;
rGPR[_inst.RA] = uAddress;
}
}
int ConvertReadDouble(int fp,double *val) {
unsigned char tmp[8];
int s=0,o=0,l=8;
while (o<8) {
s=read(fp,tmp+o,l);
o=o+s;
l=l-s;
if (s==0) return -1;
if (s==-1) return -1;
}
ConvertToDouble(tmp,val);
return 0;
}
void Interpreter::lfsx(UGeckoInstruction inst)
{
const u32 address = Helper_Get_EA_X(inst);
if ((address & 0b11) != 0)
{
GenerateAlignmentException(address);
return;
}
const u32 temp = PowerPC::Read_U32(address);
if (!(PowerPC::ppcState.Exceptions & EXCEPTION_DSI))
{
const u64 value = ConvertToDouble(temp);
riPS0(inst.FD) = value;
riPS1(inst.FD) = value;
}
}
int xlw::XlfOper4::ConvertToDoubleVector(std::vector<double>& v, DoubleVectorConvPolicy policy) const
{
if (lpxloper_->xltype == xltypeMissing)
{
v.resize(0);
return xlretSuccess;
}
if (lpxloper_->xltype & xltypeNum)
{
// first test if double
double d=0.0;
int xlret1 = ConvertToDouble(d);
if (xlret1 == xlretSuccess)
{
v.resize(1);
v[0] = d;
return xlret1;
}
}
if (lpxloper_->xltype & xltypeMulti)
{
size_t nbRows = lpxloper_->val.array.rows;
size_t nbCols = lpxloper_->val.array.columns;
bool isUniDimRange = ( nbRows == 1 || nbCols == 1 );
if (policy == UniDimensional && ! isUniDimRange)
// not a vector we return a failure
return xlretFailed;
size_t n = nbRows*nbCols;
v.resize(n);
for (size_t i = 0; i < nbRows; ++i)
{
for (size_t j = 0; j < nbCols; ++j)
{
size_t index;
if (policy == RowMajor)
// C-like dense matrix storage
index = i*nbCols+j;
else
// Fortran-like dense matrix storage. Does not matter if the policy is UniDimensional
index = j*nbRows+i;
unsigned long thisType = (*lpxloper_).val.array.lparray[i*nbCols+j].xltype;
if (thisType == xltypeNum)
{
v[index] = (*lpxloper_).val.array.lparray[i*nbCols+j].val.num;
}
else
{
v[index] = XlfOper(&(*lpxloper_).val.array.lparray[i*nbCols+j]).AsDouble();
}
}
}
return xlretSuccess;
}
XlfRef ref;
int xlret = ConvertToRef(ref);
if (xlret != xlretSuccess)
return xlret;
int nbRows = ref.GetNbRows();
int nbCols = ref.GetNbCols();
bool isUniDimRange = ( nbRows == 1 || nbCols == 1 );
if (policy == UniDimensional && ! isUniDimRange)
// not a vector we return a failure
return xlretFailed;
size_t n = nbRows*nbCols;
v.resize(n);
for (int i = 0; i < nbRows; ++i)
{
for (int j = 0; j < nbCols; ++j)
{
if (policy == RowMajor)
// C-like dense matrix storage
xlret = ref.element<XlfOper4>(i,j).ConvertToDouble(v[i*nbCols+j]);
else
// Fortran-like dense matrix storage. Does not matter if the policy is UniDimensional
xlret = ref.element<XlfOper4>(i,j).ConvertToDouble(v[j*nbRows+i]);
if (xlret != xlretSuccess)
return xlret;
}
}
return xlret;
};
struct DataMap *DataMapDecodeBuffer(char *buf,int size) {
int c,x,n,i,e;
int32 sn,an;
int32 code,sze;
char *name;
char *tmp;
char type;
unsigned int off=0;
int32 tsze;
struct DataMap *ptr;
struct DataMapScalar *s;
struct DataMapArray *a;
ptr=DataMapMake();
if (ptr==NULL) return NULL;
ConvertToInt(buf+off,&code);
off+=sizeof(int32);
ConvertToInt(buf+off,&sze);
off+=sizeof(int32);
ConvertToInt(buf+off,&sn);
off+=sizeof(int32);
ConvertToInt(buf+off,&an);
off+=sizeof(int32);
if (sn>0) {
ptr->snum=sn;
ptr->scl=malloc(sizeof(struct DataMapScalar *)*sn);
if (ptr->scl==NULL) {
DataMapFree(ptr);
return NULL;
}
for (c=0;c<sn;c++) ptr->scl[c]=NULL;
}
if (an>0) {
ptr->anum=an;
ptr->arr=malloc(sizeof(struct DataMapArray *)*an);
if (ptr->arr==NULL) {
DataMapFree(ptr);
return NULL;
}
for (c=0;c<an;c++) ptr->arr[c]=NULL;
}
for (c=0;c<sn;c++) {
e=0;
n=0;
while ((buf[off+n] !=0) && (off+n<size)) n++;
if (off+n>=size) break;
name=malloc(n+1);
if (name==NULL) break;
memcpy(name,buf+off,n+1);
off+=n+1;
type=buf[off];
off++;
s=malloc(sizeof(struct DataMapScalar));
if (s==NULL) {
free(name);
break;
}
s->name=name;
s->mode=6;
s->type=type;
ptr->scl[c]=s;
switch (s->type) {
case DATACHAR:
s->data.vptr=malloc(sizeof(char));
if (s->data.vptr==NULL) {
e=1;
break;
}
s->data.cptr[0]=buf[off];
off++;
break;
case DATASHORT:
s->data.vptr=malloc(sizeof(int16));
if (s->data.vptr==NULL) {
e=1;
break;
}
ConvertToShort(buf+off,s->data.sptr);
off+=sizeof(int16);
break;
case DATAINT:
s->data.vptr=malloc(sizeof(int32));
if (s->data.vptr==NULL) {
e=1;
break;
}
ConvertToInt(buf+off,s->data.iptr);
off+=sizeof(int32);
break;
case DATALONG:
s->data.vptr=malloc(sizeof(int64));
if (s->data.vptr==NULL) {
e=1;
break;
}
ConvertToLong(buf+off,s->data.lptr);
off+=sizeof(int64);
break;
case DATAUCHAR:
s->data.vptr=malloc(sizeof(unsigned char));
if (s->data.vptr==NULL) {
e=1;
break;
}
s->data.ucptr[0]=buf[off];
off++;
break;
case DATAUSHORT:
s->data.vptr=malloc(sizeof(uint16));
if (s->data.vptr==NULL) {
e=1;
break;
}
ConvertToUShort(buf+off,s->data.usptr);
off+=sizeof(uint16);
break;
case DATAUINT:
s->data.vptr=malloc(sizeof(uint32));
if (s->data.vptr==NULL) {
e=1;
break;
}
ConvertToUInt(buf+off,s->data.uiptr);
off+=sizeof(uint32);
break;
case DATAULONG:
s->data.vptr=malloc(sizeof(uint64));
if (s->data.vptr==NULL) {
e=1;
break;
}
ConvertToULong(buf+off,s->data.ulptr);
off+=sizeof(uint64);
break;
case DATAFLOAT:
s->data.vptr=malloc(sizeof(float));
if (s->data.vptr==NULL) {
e=1;
break;
}
ConvertToFloat(buf+off,s->data.fptr);
off+=sizeof(float);
break;
case DATADOUBLE:
s->data.vptr=malloc(sizeof(double));
if (s->data.vptr==NULL) {
e=1;
break;
}
ConvertToDouble(buf+off,s->data.dptr);
off+=sizeof(double);
break;
case DATASTRING:
n=0;
while ((buf[off+n] !=0) && (off+n<size)) n++;
if (off+n>=size) {
e=1;
break;
}
s->data.vptr=malloc(sizeof(char *));
if (s->data.vptr==NULL) {
e=1;
break;
}
if (n !=0) {
tmp=malloc(n+1);
if (tmp==NULL) {
e=1;
break;
}
memcpy(tmp,buf+off,n+1);
off+=n+1;
*( (char **) s->data.vptr)=tmp;
} else {
*( (char **) s->data.vptr)=NULL;
off++;
}
break;
default:
s->data.vptr=malloc(sizeof(struct DataMap *));
if (s->data.vptr==NULL) {
e=1;
break;
}
ConvertToInt(buf+off,&tsze);
off+=sizeof(int32);
if (tsze !=0) {
*s->data.mptr=DataMapDecodeBuffer(buf+off,tsze);
off+=tsze;
} else *s->data.mptr=NULL;
}
if (e==1) break;
}
if (c !=sn) {
DataMapFree(ptr);
return NULL;
}
for (c=0;c<an;c++) {
e=0;
n=0;
while ((buf[off+n] !=0) && (off+n<size)) n++;
if (off+n>=size) break;
name=malloc(n+1);
if (name==NULL) break;
memcpy(name,buf+off,n+1);
off+=n+1;
type=buf[off];
off++;
a=malloc(sizeof(struct DataMapArray));
if (a==NULL) {
free(name);
break;
}
a->name=name;
a->mode=7;
a->type=type;
ptr->arr[c]=a;
ConvertToInt(buf+off,(int32 *) &(a->dim));
off+=sizeof(int32);
a->rng=malloc(a->dim*sizeof(int32));
if (a->rng==NULL) break;
for (x=0;x<a->dim;x++) {
ConvertToInt(buf+off,&a->rng[x]);
off+=sizeof(int32);
}
if (x!=a->dim) break;
n=1;
for (x=0;x<a->dim;x++) n=a->rng[x]*n;
switch (a->type) {
case DATACHAR:
a->data.vptr=malloc(sizeof(char)*n);
if (a->data.vptr==NULL) {
e=1;
break;
}
memcpy(a->data.cptr,buf+off,sizeof(char)*n);
off+=sizeof(char)*n;
break;
case DATASHORT:
a->data.vptr=malloc(sizeof(int16)*n);
if (a->data.vptr==NULL) {
e=1;
break;
}
for (x=0;x<n;x++) {
ConvertToShort(buf+off,&a->data.sptr[x]);
off+=sizeof(int16);
}
break;
case DATAINT:
a->data.vptr=malloc(sizeof(int32)*n);
if (a->data.vptr==NULL) {
break;
e=1;
}
for (x=0;x<n;x++) {
ConvertToInt(buf+off,&a->data.iptr[x]);
off+=sizeof(int32);
}
break;
case DATALONG:
a->data.vptr=malloc(sizeof(int64)*n);
if (a->data.vptr==NULL) {
e=1;
break;
}
for (x=0;x<n;x++) {
ConvertToLong(buf+off,&a->data.lptr[x]);
off+=sizeof(int64);
}
break;
case DATAUCHAR:
a->data.vptr=malloc(sizeof(unsigned char)*n);
if (a->data.vptr==NULL) {
e=1;
break;
}
memcpy(a->data.cptr,buf+off,sizeof(unsigned char)*n);
off+=sizeof(unsigned char)*n;
break;
case DATAUSHORT:
a->data.vptr=malloc(sizeof(uint16)*n);
if (a->data.vptr==NULL) {
e=1;
break;
}
for (x=0;x<n;x++) {
ConvertToUShort(buf+off,&a->data.usptr[x]);
off+=sizeof(uint16);
}
break;
case DATAUINT:
a->data.vptr=malloc(sizeof(uint32)*n);
if (a->data.vptr==NULL) {
e=1;
break;
}
for (x=0;x<n;x++) {
ConvertToUInt(buf+off,&a->data.uiptr[x]);
off+=sizeof(uint32);
}
break;
case DATAULONG:
a->data.vptr=malloc(sizeof(uint64)*n);
if (a->data.vptr==NULL) {
e=1;
break;
}
for (x=0;x<n;x++) {
ConvertToULong(buf+off,&a->data.ulptr[x]);
off+=sizeof(uint64);
}
break;
case DATAFLOAT:
a->data.vptr=malloc(sizeof(float)*n);
if (a->data.vptr==NULL) {
e=1;
break;
}
for (x=0;x<n;x++) {
ConvertToFloat(buf+off,&a->data.fptr[x]);
off+=sizeof(float);
}
break;
case DATADOUBLE:
a->data.vptr=malloc(sizeof(double)*n);
if (a->data.vptr==NULL) {
e=1;
break;
}
for (x=0;x<n;x++) {
ConvertToDouble(buf+off,&a->data.dptr[x]);
off+=sizeof(double);
}
break;
case DATASTRING:
a->data.vptr=malloc(sizeof(char *)*n);
if (a->data.vptr==NULL) {
e=1;
break;
}
for (x=0;x<n;x++) {
i=0;
while ((buf[off+i] !=0) && (off+i<size)) i++;
if (off+i>=size) break;
if (i !=0) {
tmp=malloc(i+1);
if (tmp==NULL) break;
memcpy(tmp,buf+off,i+1);
((char **) a->data.vptr)[x]=tmp;
} else ((char **) a->data.vptr)[x]=NULL;
off+=i+1;
}
if (x !=n) e=1;
break;
default:
a->data.mptr=malloc(sizeof(struct DataMap *)*n);
if (a->data.vptr==NULL) {
e=1;
break;
}
for (x=0;x<n;x++) {
ConvertToInt(buf+off,&tsze);
off+=sizeof(int32);
if (tsze !=0) {
a->data.mptr[x]=DataMapDecodeBuffer(buf+off,tsze);
off+=tsze;
} else a->data.mptr[x]=0;
}
}
if (e==1) break;
}
if (c !=an) {
DataMapFree(ptr);
return NULL;
}
return ptr;
}
int OldFitCnxDecodeIPMsg(struct RadarParm *prm,struct FitData *fit,
unsigned char *buffer) {
unsigned char *buf;
unsigned char *gsct;
unsigned char *dflg;
struct radar_parms oldprm;
int pat[]={1,2,2,17,4,2,2,14,4,4,2,4,0,0};
int i;
int rng_num=0;
int index;
if (buffer[0] !='d') return 0;
buf=buffer+1;
ConvertBlock(buf,pat);
memcpy(&oldprm,buf,sizeof(struct radar_parms));
buf+=sizeof(struct radar_parms);
gsct=buf;
dflg=buf+10;
buf+=20;
prm->revision.major=oldprm.REV.MAJOR;
prm->revision.minor=oldprm.REV.MINOR;
prm->cp=oldprm.CP;
prm->stid=oldprm.ST_ID;
prm->time.yr=oldprm.YEAR;
prm->time.mo=oldprm.MONTH;
prm->time.dy=oldprm.DAY;
prm->time.hr=oldprm.HOUR;
prm->time.mt=oldprm.MINUT;
prm->time.sc=oldprm.SEC;
prm->time.us=0;
prm->txpow=oldprm.TXPOW;
prm->nave=oldprm.NAVE;
prm->atten=oldprm.ATTEN;
prm->lagfr=oldprm.LAGFR;
prm->smsep=oldprm.SMSEP;
prm->ercod=oldprm.ERCOD;
prm->stat.agc=oldprm.AGC_STAT;
prm->stat.lopwr=oldprm.LOPWR_STAT;
prm->noise.search=oldprm.NOISE;
prm->noise.mean=oldprm.NOISE_MEAN;
prm->channel=oldprm.CHANNEL;
prm->bmnum=oldprm.BMNUM;
prm->scan=oldprm.SCAN;
prm->offset=oldprm.usr_resL1;
prm->rxrise=oldprm.RXRISE;
prm->intt.sc=oldprm.INTT;
prm->intt.us=0;
prm->txpl=oldprm.TXPL;
prm->mpinc=oldprm.MPINC;
prm->mppul=oldprm.MPPUL;
prm->mplgs=oldprm.MPLGS;
prm->nrang=oldprm.NRANG;
prm->frang=oldprm.FRANG;
prm->rsep=oldprm.RSEP;
prm->xcf=oldprm.XCF;
prm->tfreq=oldprm.TFREQ;
prm->mxpwr=oldprm.MXPWR;
prm->lvmax=oldprm.LVMAX;
for (i=0;i<MAX_RANGE;i++) {
fit->rng[i].qflg=0;
fit->rng[i].gsct=0;
fit->rng[i].v=0;
fit->rng[i].v_err=0;
fit->rng[i].p_0=0;
fit->rng[i].p_l=0;
fit->rng[i].p_l_err=0;
fit->rng[i].p_s=0;
fit->rng[i].p_s_err=0;
fit->rng[i].w_l=0;
fit->rng[i].w_l_err=0;
fit->rng[i].w_s=0;
fit->rng[i].w_s_err=0;
fit->rng[i].phi0=0;
fit->rng[i].phi0_err=0;
fit->rng[i].sdev_l=0;
fit->rng[i].sdev_s=0;
fit->rng[i].sdev_phi=0;
fit->rng[i].nump=0;
}
for (i=0;i<ORIG_MAX_RANGE;i++) {
if (read_bit(dflg,i) !=0) {
fit->rng[i].qflg=1;
rng_num++;
}
}
if (rng_num == 0) return 1;
index=0;
for (i=0;i<ORIG_MAX_RANGE;i++) {
if (fit->rng[i].qflg !=0) {
if (read_bit(gsct,i) !=0) fit->rng[i].gsct=1;
ConvertToDouble(buf+8*index,&fit->rng[i].p_l);
ConvertToDouble(buf+8*(index+rng_num),&fit->rng[i].v);
ConvertToDouble(buf+8*(index+2*rng_num),&fit->rng[i].w_l);
index++;
}
}
return 1;
}
struct DataMap *DataMapDecodeBuffer(unsigned char *buf,int size) {
int c,x,n,i;
int32 sn,an;
int32 code,sze;
char *name;
unsigned char *tmp;
char type;
unsigned int off=0;
struct DataMap *ptr;
struct DataMapScalar *s;
struct DataMapArray *a;
ptr=DataMapMake();
if (ptr==NULL) return NULL;
ConvertToInt(buf+off,&code);
off+=sizeof(int32);
ConvertToInt(buf+off,&sze);
off+=sizeof(int32);
ConvertToInt(buf+off,&sn);
off+=sizeof(int32);
ConvertToInt(buf+off,&an);
off+=sizeof(int32);
if (sn>0) {
ptr->snum=sn;
ptr->scl=malloc(sizeof(struct DataMapScalar *)*sn);
if (ptr->scl==NULL) {
DataMapFree(ptr);
return NULL;
}
for (c=0;c<sn;c++) ptr->scl[c]=NULL;
}
if (an>0) {
ptr->anum=an;
ptr->arr=malloc(sizeof(struct DataMapArray *)*an);
if (ptr->arr==NULL) {
DataMapFree(ptr);
return NULL;
}
for (c=0;c<an;c++) ptr->arr[c]=NULL;
}
for (c=0;c<sn;c++) {
n=0;
while ((buf[off+n] !=0) && (off+n<size)) n++;
if (off+n>=size) break;
name=malloc(n+1);
if (name==NULL) break;
memcpy(name,buf+off,n+1);
off+=n+1;
type=buf[off];
off++;
s=malloc(sizeof(struct DataMapScalar));
if (s==NULL) {
free(name);
break;
}
s->name=name;
s->mode=1;
s->type=type;
ptr->scl[c]=s;
switch (s->type) {
case DATACHAR:
s->data.vptr=malloc(sizeof(char));
if (s->data.vptr==NULL) break;
s->data.cptr[0]=buf[off];
off++;
break;
case DATASHORT:
s->data.vptr=malloc(sizeof(int16));
if (s->data.vptr==NULL) break;
ConvertToShort(buf+off,s->data.sptr);
off+=sizeof(int16);
break;
case DATAINT:
s->data.vptr=malloc(sizeof(int32));
if (s->data.vptr==NULL) break;
ConvertToInt(buf+off,s->data.iptr);
off+=sizeof(int32);
break;
case DATAFLOAT:
s->data.vptr=malloc(sizeof(float));
if (s->data.vptr==NULL) break;
ConvertToFloat(buf+off,s->data.fptr);
off+=sizeof(float);
break;
case DATADOUBLE:
s->data.vptr=malloc(sizeof(double));
if (s->data.vptr==NULL) break;
ConvertToDouble(buf+off,s->data.dptr);
off+=sizeof(double);
break;
default:
n=0;
while ((buf[off+n] !=0) && (off+n<size)) n++;
if (off+n>=size) break;
s->data.vptr=malloc(sizeof(char *));
if (s->data.vptr==NULL) break;
tmp=realloc(ptr->buf,ptr->sze+n+1);
if (tmp==NULL) break;
ptr->buf=tmp;
memcpy(ptr->buf+ptr->sze,buf+off,n+1);
off+=n+1;
*(s->data.optr)=ptr->sze;
ptr->sze+=n+1;
break;
}
}
if (c !=sn) {
DataMapFree(ptr);
return NULL;
}
for (c=0;c<an;c++) {
n=0;
while ((buf[off+n] !=0) && (off+n<size)) n++;
if (off+n>=size) break;
name=malloc(n+1);
if (name==NULL) break;
memcpy(name,buf+off,n+1);
off+=n+1;
type=buf[off];
off++;
a=malloc(sizeof(struct DataMapArray));
if (a==NULL) {
free(name);
break;
}
a->name=name;
a->mode=3;
a->type=type;
ptr->arr[c]=a;
ConvertToInt(buf+off,(int32 *) &(a->dim));
off+=sizeof(int32);
a->rng=malloc(a->dim*sizeof(int32));
if (a->rng==NULL) break;
for (x=0;x<a->dim;x++) {
ConvertToInt(buf+off,&a->rng[x]);
off+=sizeof(int32);
}
if (x!=a->dim) break;
n=1;
for (x=0;x<a->dim;x++) n=a->rng[x]*n;
switch (a->type) {
case DATACHAR:
a->data.vptr=malloc(sizeof(char)*n);
if (a->data.vptr==NULL) break;
memcpy(a->data.cptr,buf+off,sizeof(char)*n);
off+=sizeof(char)*n;
break;
case DATASHORT:
a->data.vptr=malloc(sizeof(int16)*n);
if (a->data.vptr==NULL) break;
for (x=0;x<n;x++) {
ConvertToShort(buf+off,&a->data.sptr[x]);
off+=sizeof(int16);
}
break;
case DATAINT:
a->data.vptr=malloc(sizeof(int32)*n);
if (a->data.vptr==NULL) break;
for (x=0;x<n;x++) {
ConvertToInt(buf+off,&a->data.iptr[x]);
off+=sizeof(int32);
}
break;
case DATAFLOAT:
a->data.vptr=malloc(sizeof(float)*n);
if (a->data.vptr==NULL) break;
for (x=0;x<n;x++) {
ConvertToFloat(buf+off,&a->data.fptr[x]);
off+=sizeof(float);
}
break;
case DATADOUBLE:
a->data.vptr=malloc(sizeof(double)*n);
if (a->data.vptr==NULL) break;
for (x=0;x<n;x++) {
ConvertToDouble(buf+off,&a->data.dptr[x]);
off+=sizeof(double);
}
break;
default:
a->data.vptr=malloc(sizeof(char *)*n);
if (a->data.vptr==NULL) break;
for (x=0;x<n;x++) {
i=0;
while ((buf[off+i] !=0) && (off+i<size)) i++;
if (off+i>=size) break;
tmp=realloc(ptr->buf,ptr->sze+i+1);
if (tmp==NULL) break;
ptr->buf=tmp;
memcpy(ptr->buf+ptr->sze,buf+off,i+1);
a->data.optr[x]=ptr->sze;
ptr->sze+=i+1;
off+=i+1;
}
if (x !=n) break;
}
}
if (c !=an) {
DataMapFree(ptr);
return NULL;
}
for (c=0;c<ptr->snum;c++) {
if (ptr->scl[c]==NULL) continue;
s=ptr->scl[c];
if (s->type==DATASTRING)
*((char **) s->data.vptr)=(char *) (ptr->buf+*(s->data.optr));
}
for (c=0;c<ptr->anum;c++) {
if (ptr->arr[c]==NULL) continue;
a=ptr->arr[c];
if (a->type==DATASTRING) {
n=1;
for (x=0;x<a->dim;x++) n=a->rng[x]*n;
for (x=0;x<n;x++)
( (char **) a->data.vptr)[x]=(char *) (ptr->buf+a->data.optr[x]);
}
}
return ptr;
}
int CFitRead(struct CFitfp *fptr,struct CFitdata *ptr) {
float val;
int i;
if (fptr->fp !=-1) {
if (ConvertReadDouble(fptr->fp,&ptr->time) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->stid) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->scan) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->cp) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->bmnum) !=0) return -1;
if (ConvertReadFloat(fptr->fp,&ptr->bmazm) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->channel) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->intt.sc) !=0) return -1;
if (ConvertReadInt(fptr->fp,&ptr->intt.us) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->frang) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->rsep) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->rxrise) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->tfreq) !=0) return -1;
if (ConvertReadInt(fptr->fp,&ptr->noise) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->atten) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->nave) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->nrang) !=0) return -1;
} else {
if ((fptr->fptr+sizeof(double)+7*sizeof(int16)+
sizeof(int32)+sizeof(float))>fptr->fsze) return -1;
ConvertToDouble(&fptr->fbuf[fptr->fptr],&ptr->time);
fptr->fptr+=sizeof(double);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->stid);
fptr->fptr+=sizeof(int16);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->scan);
fptr->fptr+=sizeof(int16);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->cp);
fptr->fptr+=sizeof(int16);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->bmnum);
fptr->fptr+=sizeof(int16);
ConvertToFloat(fptr->fbuf+fptr->fptr,&ptr->bmazm);
fptr->fptr+=sizeof(float);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->channel);
fptr->fptr+=sizeof(int16);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->intt.sc);
fptr->fptr+=sizeof(int16);
ConvertToInt(fptr->fbuf+fptr->fptr,&ptr->intt.us);
fptr->fptr+=sizeof(int32);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->frang);
fptr->fptr+=sizeof(int16);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->rsep);
fptr->fptr+=sizeof(int16);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->rxrise);
fptr->fptr+=sizeof(int16);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->tfreq);
fptr->fptr+=sizeof(int16);
ConvertToInt(fptr->fbuf+fptr->fptr,&ptr->noise);
fptr->fptr+=sizeof(int32);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->atten);
fptr->fptr+=sizeof(int16);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->nave);
fptr->fptr+=sizeof(int16);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->nrang);
fptr->fptr+=sizeof(int16);
}
fptr->ctime=ptr->time;
if (fptr->fp !=-1) {
if (read(fptr->fp,&ptr->num,1) !=1) return -1;
if (read(fptr->fp,ptr->rng,ptr->num) !=ptr->num) return -1;
} else {
if (fptr->fptr>=fptr->fsze) return -1;
ptr->num=fptr->fbuf[fptr->fptr];
fptr->fptr+=1;
if ((fptr->fptr+ptr->num)>=fptr->fsze) return -1;
memcpy(ptr->rng,&fptr->fbuf[fptr->fptr],ptr->num);
fptr->fptr+=ptr->num;
}
for (i=0;i<ptr->num;i++) {
if (fptr->fp !=-1) {
if (read(fptr->fp,&ptr->data[i].gsct,1) !=1) return -1;
if (ptr->data[i].gsct==EOF) return -1;
if (ConvertReadFloat(fptr->fp,&val) !=0) return -1;
ptr->data[i].p_0=val;
if (ConvertReadFloat(fptr->fp,&val) !=0) return -1;
ptr->data[i].p_0_e=val;
if (ConvertReadFloat(fptr->fp,&val) !=0) return -1;
ptr->data[i].v=val;
if (ConvertReadFloat(fptr->fp,&val) !=0) return -1;
ptr->data[i].p_l=val;
if (ConvertReadFloat(fptr->fp,&val) !=0) return -1;
ptr->data[i].w_l=val;
if (ConvertReadFloat(fptr->fp,&val) !=0) return -1;
ptr->data[i].v_e=val;
if (ConvertReadFloat(fptr->fp,&val) !=0) return -1;
ptr->data[i].p_l_e=val;
if (ConvertReadFloat(fptr->fp,&val) !=0) return -1;
ptr->data[i].w_l_e=val;
} else {
if ((fptr->fptr+1+sizeof(float)*6)>=fptr->fsze) return -1;
ptr->data[i].gsct=fptr->fbuf[fptr->fptr];
fptr->fptr+=1;
ConvertToFloat(fptr->fbuf+fptr->fptr,&val);
fptr->fptr+=sizeof(float);
ptr->data[i].p_0=val;
ConvertToFloat(fptr->fbuf+fptr->fptr,&val);
fptr->fptr+=sizeof(float);
ptr->data[i].p_0_e=val;
ConvertToFloat(fptr->fbuf+fptr->fptr,&val);
fptr->fptr+=sizeof(float);
ptr->data[i].v=val;
ConvertToFloat(fptr->fbuf+fptr->fptr,&val);
fptr->fptr+=sizeof(float);
ptr->data[i].p_l=val;
ConvertToFloat(fptr->fbuf+fptr->fptr,&val);
fptr->fptr+=sizeof(float);
ptr->data[i].w_l=val;
ConvertToFloat(fptr->fbuf+fptr->fptr,&val);
fptr->fptr+=sizeof(float);
ptr->data[i].v_e=val;
ConvertToFloat(fptr->fbuf+fptr->fptr,&val);
fptr->fptr+=sizeof(float);
ptr->data[i].p_l_e=val;
ConvertToFloat(fptr->fbuf+fptr->fptr,&val);
fptr->fptr+=sizeof(float);
ptr->data[i].w_l_e=val;
}
}
return 0;
}
