int32 OldRawIDLSeek(int argc,char *argv[]) {
struct OldRawIDLFp *idlrawfp;
struct OldRawFp rawfp;
IDL_FILE_STAT stat;
FILE *fp;
int s;
int32 yr,mo,dy,hr,mt;
double sc;
double *atme;
idlrawfp=(struct OldRawIDLFp *) argv[0];
IDL_FileStat(idlrawfp->rawunit,&stat);
/* Find the file pointer */
fp=stat.fptr;
if (fp==NULL) return -1;
fflush(fp);
rawfp.rawfp=fileno(fp);
rawfp.inxfp=0;
yr=*( (int32 *) argv[1]);
mo=*( (int32 *) argv[2]);
dy=*( (int32 *) argv[3]);
hr=*( (int32 *) argv[4]);
mt=*( (int32 *) argv[5]);
sc=*( (double *) argv[6]);
atme=(double *) argv[7];
OldRawIDLToRawFp(idlrawfp,&rawfp);
s=OldRawSeek(&rawfp,yr,mo,dy,hr,mt,sc,atme);
OldRawRawFpToIDL(&rawfp,idlrawfp);
return s;
}
int32 OldRawIDLOpen(int argc,char *argv[]) {
struct OldRawIDLFp *idlrawfp;
struct OldRawFp *rawfp;
IDL_FILE_STAT stat;
FILE *fp;
int unit;
int s;
unit = *( (int32 *) argv[0]);
/* Make sure that the "STDIO" keyword was used to
* open the file in IDL.
*/
s=IDL_FileEnsureStatus(IDL_MSG_RET,unit,IDL_EFS_STDIO);
if (s==FALSE) return -1;
/* Get information about the file */
IDL_FileStat(unit,&stat);
/* Find the file pointer */
fp=stat.fptr;
if (fp==NULL) return -1;
fflush(fp);
rawfp=OldRawOpenFd(fileno(fp),0);
idlrawfp=(struct OldRawIDLFp *) argv[1];
idlrawfp->rawunit=unit;
idlrawfp->inxunit=0;
OldRawRawFpToIDL(rawfp,idlrawfp);
free(rawfp);
return s;
}
static IDL_VPTR IDLOldRawOpen(int argc,IDL_VPTR *argv) {
IDL_VPTR vrawfp;
struct OldRawIDLFp *irawfp;
struct OldRawFp *rawfp;
void *s;
int st;
static IDL_MEMINT hdim[]={1,80};
static IDL_MEMINT ddim[]={1,32};
static IDL_MEMINT edim[]={1,256};
static IDL_STRUCT_TAG_DEF trawfp[]={
{"RAWUNIT",0,(void *) IDL_TYP_LONG},
{"INXUNIT",0,(void *) IDL_TYP_LONG},
{"RAW_RECL",0,(void *) IDL_TYP_LONG},
{"INX_RECL",0,(void *) IDL_TYP_LONG},
{"BLEN",0,(void *) IDL_TYP_LONG},
{"INX_SREC",0,(void *) IDL_TYP_LONG},
{"INX_EREC",0,(void *) IDL_TYP_LONG},
{"CTIME",0,(void *) IDL_TYP_DOUBLE},
{"STIME",0,(void *) IDL_TYP_DOUBLE},
{"ETIME",0,(void *) IDL_TYP_DOUBLE},
{"TIME",0,(void *) IDL_TYP_LONG},
{"HEADER",hdim,(void *) IDL_TYP_BYTE},
{"DATE",ddim,(void *) IDL_TYP_BYTE},
{"EXTRA",edim,(void *) IDL_TYP_BYTE},
{"MAJOR_REV",0,(void *) IDL_TYP_BYTE},
{"MINOR_REV",0,(void *) IDL_TYP_BYTE},
{"RAWREAD",0,(void *) IDL_TYP_LONG},
{"BNUM",0,(void *) IDL_TYP_LONG},
0};
static IDL_MEMINT ilDims[IDL_MAX_ARRAY_DIM];
IDL_VARIABLE unit;
IDL_VPTR fargv[2];
IDL_FILE_STAT stat;
int ffd=-1,ifd=-1;
IDL_ENSURE_STRING(argv[0]);
if (argc>1) IDL_ENSURE_STRING(argv[1]);
s=IDL_MakeStruct("RAWFP",trawfp);
ilDims[0]=1;
irawfp=(struct OldRawIDLFp *) IDL_MakeTempStruct(s,1,ilDims,&vrawfp,TRUE);
unit.type=IDL_TYP_LONG;
unit.flags=0;
fargv[0]=&unit;
fargv[1]=argv[0];
IDL_FileGetUnit(1,fargv);
IDL_FileOpen(2,fargv,NULL,IDL_OPEN_R,IDL_F_STDIO,1,0);
irawfp->rawunit=IDL_LongScalar(&unit);
irawfp->inxunit=-1;
st=IDL_FileEnsureStatus(IDL_MSG_RET,irawfp->rawunit,IDL_EFS_USER);
if (st==FALSE) {
st=0;
IDL_Deltmp(vrawfp);
return (IDL_GettmpLong(st));
}
if (argc>1) {
fargv[1]=argv[1];
IDL_FileGetUnit(1,fargv);
IDL_FileOpen(2,fargv,NULL,IDL_OPEN_R,IDL_F_STDIO,1,0);
irawfp->inxunit=IDL_LongScalar(&unit);
st=IDL_FileEnsureStatus(IDL_MSG_RET,irawfp->rawunit,IDL_EFS_USER);
if (st==FALSE) { /* free unit for index but continue */
IDL_FileFreeUnit(1,argv);
irawfp->inxunit=-1;
}
}
IDL_FileStat(irawfp->rawunit,&stat);
ffd=fileno(stat.fptr);
if (irawfp->inxunit !=-1) {
IDL_FileStat(irawfp->inxunit,&stat);
ifd=fileno(stat.fptr);
}
rawfp=OldRawOpenFd(ffd,ifd);
OldRawRawFpToIDL(rawfp,irawfp);
free(rawfp);
return vrawfp;
}
static IDL_VPTR IDLOldRawSeek(int argc,IDL_VPTR *argv,char *argk) {
IDL_FILE_STAT stat;
struct OldRawIDLFp *irawfp;
struct OldRawFp rawfp;
int s=0;
static IDL_VPTR vatme;
double atme=0;
IDL_VPTR outargv[8];
static IDL_KW_PAR kw_pars[]={IDL_KW_FAST_SCAN,
{"ATME",IDL_TYP_UNDEF,1,
IDL_KW_OUT | IDL_KW_ZERO,0,
IDL_CHARA(vatme)},
{NULL}};
IDL_LONG yr=0,mo=0,dy=0,hr=0,mt=0,sc=0;
FILE *ffp=NULL,*ifp=NULL;
IDL_KWCleanup(IDL_KW_MARK);
IDL_KWGetParams(argc,argv,argk,kw_pars,outargv,1);
IDL_ENSURE_STRUCTURE(outargv[0]);
IDL_ENSURE_SCALAR(outargv[1]);
IDL_ENSURE_SCALAR(outargv[2]);
IDL_ENSURE_SCALAR(outargv[3]);
IDL_ENSURE_SCALAR(outargv[4]);
IDL_ENSURE_SCALAR(outargv[5]);
IDL_ENSURE_SCALAR(outargv[6]);
yr=IDL_LongScalar(outargv[1]);
mo=IDL_LongScalar(outargv[2]);
dy=IDL_LongScalar(outargv[3]);
hr=IDL_LongScalar(outargv[4]);
mt=IDL_LongScalar(outargv[5]);
sc=IDL_LongScalar(outargv[6]);
irawfp=(struct OldRawIDLFp *) outargv[0]->value.s.arr->data;
s=IDL_FileEnsureStatus(IDL_MSG_RET,irawfp->rawunit,IDL_EFS_USER);
if (s==FALSE) {
s=-1;
return (IDL_GettmpLong(s));
}
IDL_FileFlushUnit(irawfp->rawunit);
IDL_FileStat(irawfp->rawunit,&stat);
ffp=stat.fptr;
if (ffp==NULL) {
s=-1;
return (IDL_GettmpLong(s));
}
if (irawfp->inxunit !=-1) {
IDL_FileFlushUnit(irawfp->inxunit);
IDL_FileStat(irawfp->inxunit,&stat);
ifp=stat.fptr;
}
if (ifp !=NULL) fflush(ifp);
rawfp.rawfp=fileno(ffp);
if (ifp !=NULL) rawfp.inxfp=fileno(ifp);
else rawfp.inxfp=-1;
OldRawIDLToRawFp(irawfp,&rawfp);
s=OldRawSeek(&rawfp,yr,mo,dy,hr,mt,sc,&atme);
OldRawRawFpToIDL(&rawfp,irawfp);
if (vatme) IDL_StoreScalar(vatme,IDL_TYP_DOUBLE,(IDL_ALLTYPES *) &atme);
IDL_KWCleanup(IDL_KW_CLEAN);
return (IDL_GettmpLong(s));
}
static IDL_VPTR IDLOldRawRead(int argc,IDL_VPTR *argv) {
int s=0;
IDL_VPTR vprm=NULL,vraw=NULL;;
IDL_FILE_STAT stat;
struct OldRawIDLFp *irawfp;
struct OldRawFp rawfp;
struct RadarIDLParm *iprm=NULL;
struct RawIDLData *iraw=NULL;
struct RadarParm *prm=NULL;
struct RawData *raw=NULL;
FILE *ffp=NULL,*ifp=NULL;
IDL_ENSURE_STRUCTURE(argv[0]);
IDL_EXCLUDE_EXPR(argv[1]);
IDL_EXCLUDE_EXPR(argv[2]);
irawfp=(struct OldRawIDLFp *) argv[0]->value.s.arr->data;
s=IDL_FileEnsureStatus(IDL_MSG_RET,irawfp->rawunit,IDL_EFS_USER);
if (s==FALSE) {
s=-1;
return (IDL_GettmpLong(s));
}
IDL_FileFlushUnit(irawfp->rawunit);
IDL_FileStat(irawfp->rawunit,&stat);
ffp=stat.fptr;
if (ffp==NULL) {
s=-1;
return (IDL_GettmpLong(s));
}
if (irawfp->inxunit !=-1) {
IDL_FileFlushUnit(irawfp->inxunit);
IDL_FileStat(irawfp->inxunit,&stat);
ifp=stat.fptr;
}
if (ifp !=NULL) fflush(ifp);
rawfp.rawfp=fileno(ffp);
if (ifp !=NULL) rawfp.inxfp=fileno(ifp);
else rawfp.inxfp=-1;
OldRawIDLToRawFp(irawfp,&rawfp);
prm=RadarParmMake();
raw=RawMake();
s=OldRawRead(&rawfp,prm,raw);
OldRawRawFpToIDL(&rawfp,irawfp);
if (s==-1) {
RadarParmFree(prm);
RawFree(raw);
return (IDL_GettmpLong(s));
}
iprm=IDLMakeRadarParm(&vprm);
iraw=IDLMakeRawData(&vraw);
/* copy data here */
IDLCopyRadarParmToIDL(prm,iprm);
IDLCopyRawDataToIDL(prm->nrang,prm->mplgs,prm->xcf,raw,iraw);
RadarParmFree(prm);
RawFree(raw);
IDL_VarCopy(vprm,argv[1]);
IDL_VarCopy(vraw,argv[2]);
return (IDL_GettmpLong(s));
}
int32 OldRawIDLRead(int argc,char *argv[]) {
int n;
int x;
struct OldRawIDLFp *idlrawfp;
struct OldRawFp rawfp;
char combftmp[COMBF_SIZE+1];
struct RadarIDLParm *idlprm;
struct RawIDLData *idlraw;
struct RadarParm prm;
struct RawData raw;
IDL_FILE_STAT stat;
FILE *fp;
int s;
/* zero out the data structures */
memset(&prm,0,sizeof(struct RadarParm));
memset(&raw,0,sizeof(struct RawData));
memset(&combftmp,0,COMBF_SIZE+1);
idlrawfp=(struct OldRawIDLFp *) argv[0];
IDL_FileStat(idlrawfp->rawunit,&stat);
/* Find the file pointer */
fp=stat.fptr;
if (fp==NULL) return -1;
fflush(fp);
rawfp.rawfp=fileno(fp);
rawfp.inxfp=0;
OldRawIDLToRawFp(idlrawfp,&rawfp);
s=OldRawRead(&rawfp,&prm,&raw);
OldRawRawFpToIDL(&rawfp,idlrawfp);
if (s==-1) return -1;
/* get the structure pointers */
idlprm=(struct RadarIDLParm *) argv[1];
idlraw=(struct RawIDLData *) argv[2];
/* load up the structures.
*
* Note: We do not do a direct memcpy as the possibility
* exists that the IDL data structure is different from
* the C data structure.
*
*/
idlprm->revision.major=prm.revision.major;
idlprm->revision.minor=prm.revision.minor;
idlprm->origin.code=prm.origin.code;
IDL_StrDelete(&idlprm->origin.time,1);
IDL_StrDelete(&idlprm->origin.command,1);
idlprm->cp=prm.cp;
idlprm->stid=prm.stid;
idlprm->time.yr=prm.time.yr;
idlprm->time.mo=prm.time.mo;
idlprm->time.dy=prm.time.dy;
idlprm->time.hr=prm.time.hr;
idlprm->time.mt=prm.time.mt;
idlprm->time.sc=prm.time.sc;
idlprm->time.us=prm.time.us;
idlprm->txpow=prm.txpow;
idlprm->nave=prm.nave;
idlprm->atten=prm.atten;
idlprm->lagfr=prm.lagfr;
idlprm->smsep=prm.smsep;
idlprm->ercod=prm.ercod;
idlprm->stat.agc=prm.stat.agc;
idlprm->stat.lopwr=prm.stat.lopwr;
idlprm->noise.search=prm.noise.search;
idlprm->noise.mean=prm.noise.mean;
idlprm->channel=prm.channel;
idlprm->bmnum=prm.bmnum;
idlprm->bmazm=prm.bmazm;
idlprm->scan=prm.scan;
idlprm->rxrise=prm.rxrise;
idlprm->intt.sc=prm.intt.sc;
idlprm->intt.us=prm.intt.us;
idlprm->txpl=prm.txpl;
idlprm->mpinc=prm.mpinc;
idlprm->mppul=prm.mppul;
idlprm->mplgs=prm.mplgs;
idlprm->nrang=prm.nrang;
idlprm->frang=prm.frang;
idlprm->rsep=prm.rsep;
idlprm->xcf=prm.xcf;
idlprm->tfreq=prm.tfreq;
idlprm->offset=prm.offset;
idlprm->mxpwr=prm.mxpwr;
idlprm->lvmax=prm.lvmax;
for (n=0;n<prm.mppul;n++) idlprm->pulse[n]=prm.pulse[n];
for (n=0;n<prm.mplgs;n++) {
idlprm->lag[n]=prm.lag[n][0];
idlprm->lag[LAG_SIZE+n]=prm.lag[n][1];
}
strncpy(combftmp,prm.combf,COMBF_SIZE);
IDL_StrDelete(&idlprm->combf,1);
IDL_StrStore(&idlprm->combf,combftmp);
idlraw->revision.major=raw.revision.major;
idlraw->revision.minor=raw.revision.minor;
idlraw->thr=raw.thr;
for (n=0;n<prm.nrang;n++) {
idlraw->pwr0[n]=raw.pwr0[n];
for (x=0;x<prm.mplgs;x++) {
idlraw->acfd[x*MAX_RANGE+n]=raw.acfd[n][x][0];
idlraw->acfd[LAG_SIZE*MAX_RANGE+MAX_RANGE*x+n]=raw.acfd[n][x][1];
if (prm.xcf !=0) {
idlraw->xcfd[x*MAX_RANGE+n]=raw.xcfd[n][x][0];
idlraw->xcfd[LAG_SIZE*MAX_RANGE+MAX_RANGE*x+n]=raw.xcfd[n][x][1];
}
}
}
return s;
}
