static int Respond(long pier, long pid)
{
ASSERT(!pier || !pid);
void** gc = NULL;
char* Wfifo = String(RUN_PATH "/%ld.0/%ld", pier, pid);
ASSERT(Wfifo == NULL);
gcCollect(&gc, &Wfifo);
int Wfd = open(Wfifo, O_WRONLY, 0);
ASSERT(-1 == Wfd);
int n_read = 0;
size_t total = 0;
char buf[PIPE_BUF] = {'\0', };
errno = 0;
while((n_read = read(STDIN, buf, sizeof(buf))))
{
if(-1 == n_read)
{
if(errno == EINTR
|| errno == EAGAIN
|| errno == EWOULDBLOCK
|| errno == EPIPE)
{
errno = 0;
continue;
}
break;
}
errno = 0;
int n = Write(Wfd, buf, n_read);
ASSERT(errno);
total += n_read;
}
close(Wfd);
char* answer = "Status: 200 OK" NL NL;
Write(STDOUT, answer, strlen(answer));
gcClean(gc);
return 0;
}
termPo allocateObject(heapPo H, clssPo clss, size_t amnt) {
if ((((ptrPo) currHeap->curr) + amnt) < ((ptrPo) (currHeap->limit))) {
termPo t = currHeap->curr;
H->curr = H->curr + amnt;
t->clss = clss;
#ifdef TRACEMEM
if (traceMemory) {
numAllocated++;
totalAllocated += amnt;
}
if (validateMemory) {
verifyHeap(H);
}
#endif
return t;
} else if (gcCollect(H, amnt) == Ok)
return allocateObject(H, clss, amnt);
else
return Null;
}
static int Pier(long connect)
{
ASSERT(!connect);
void** gc = NULL;
pid_t my_pid = getpid();
char** lstEnv = getEnv();
ASSERT(lstEnv == NULL);
char* Rpath = String(RUN_PATH "/%ld.0", connect);
ASSERT(Rpath == NULL);
gcCollect(&gc, &Rpath);
if (-1 == mkdir(Rpath, 00700))
{
ASSERT(errno != EEXIST);
errno = 0;
}
char* Rfifo = String(RUN_PATH "/%ld.0/%ld", connect, my_pid);
ASSERT(Rfifo == NULL);
gcCollect(&gc, &Rfifo);
ASSERT(-1 == MkFifo(Rfifo));
char* Wfifo = String(RUN_PATH "/%ld", connect);
ASSERT(Wfifo == NULL);
gcCollect(&gc, &Wfifo);
char* lock_name = String(RUN_PATH "/%ld.lock", connect);
ASSERT(lock_name == NULL);
gcCollect(&gc, &lock_name);
int Lfd = open(lock_name, O_RDWR);
if (-1 == Lfd)
{
char* answer = String("Status: 434 Requested host unavailable" NL NL \
"434 Requested host unavailable.");
gcCollect(&gc, &answer);
Write(STDOUT, answer, strlen(answer));
lstFree(lstEnv);
gcClean(gc);
unlink(Rfifo);
return 0;
}
if(-1 == lockf(Lfd, F_LOCK, 0L))
{
char* answer = String("Status: 434 Requested host unavailable" NL NL \
"434 Requested host unavailable.");
gcCollect(&gc, &answer);
Write(STDOUT, answer, strlen(answer));
lstFree(lstEnv);
gcClean(gc);
unlink(Rfifo);
return 0;
}
int Wfd = open(Wfifo, O_WRONLY | O_SYNC, 0);
if (-1 == Wfd)
{
char* answer = String("Status: 434 Requested host unavailable" NL NL \
"434 Requested host unavailable.");
gcCollect(&gc, &answer);
Write(STDOUT, answer, strlen(answer));
lstFree(lstEnv);
gcClean(gc);
unlink(Rfifo);
return 0;
}
/*
int i = 0;
char** lstEnv2 = getEnv();
for (; lstEnv2[i]; ++i)
{
TRACE("%s\n", lstEnv2[i]);
}
*/
char* header = String("%d" NL, my_pid);
ASSERT(header == NULL);
gcCollect(&gc, &header);
ASSERT(-1 == replaceStrFormat(&header, "", "%s %s %s" NL,
getenv("REQUEST_METHOD") ? getenv("REQUEST_METHOD") : "GET",
getenv("REQUEST_URI"),
getenv("SERVER_PROTOCOL") ? getenv("SERVER_PROTOCOL") : "HTTP/1.1"));
char** lstHttpEnv = lstEgrep(lstEnv, "^HTTP_.+$");
if (lstHttpEnv)
{
addHeader(&header, lstHttpEnv);
}
char** lstContentEnv = lstEgrep(lstEnv, "^CONTENT_.+$");
if (lstContentEnv)
{
addHeader(&header, lstContentEnv);
}
ASSERT(-1 == replaceStrFormat(&header, "", NL));
errno = 0;
int n = Write(Wfd, header, strlen(header));
ASSERT(errno);
int n_read = 0;
size_t total = 0;
char buf[PIPE_BUF] = {'\0', };
errno = 0;
while((n_read = read(0, buf, sizeof(buf))))
{
if(-1 == n_read)
{
if(errno == EINTR
|| errno == EAGAIN
|| errno == EWOULDBLOCK
|| errno == EPIPE)
{
errno = 0;
continue;
}
break;
}
errno = 0;
int n = Write(Wfd, buf, n_read);
ASSERT(errno);
total += n;
}
ASSERT(-1 == close(Wfd));
//TRACE("\n%d %d >>\n", getpid(), time(NULL));
int Rfd = open(Rfifo, O_RDONLY, 0);
ASSERT(-1 == Rfd);
n_read = 0;
total = 0;
errno = 0;
while((n_read = read(Rfd, buf, sizeof(buf))))
{
if(-1 == n_read)
{
if(errno == EINTR
|| errno == EAGAIN
|| errno == EWOULDBLOCK
|| errno == EPIPE)
{
errno = 0;
continue;
}
break;
}
errno = 0;
int n = Write(STDOUT, buf, n_read);
ASSERT(errno);
total += n_read;
}
//TRACE("\n%d %d <<\n", getpid(), time(NULL));
ASSERT(-1 == close(Rfd));
ASSERT(-1 == lockf(Lfd, F_ULOCK, 0L));
ASSERT(-1 == close(Lfd));
ASSERT(-1 == unlink(Rfifo));
lstFree(lstEnv);
lstFree(lstHttpEnv);
lstFree(lstContentEnv);
gcClean(gc);
return 0;
}
static int Connect(long connect)
{
ASSERT(!connect);
void** gc = NULL;
char* Rfifo = String(RUN_PATH "/%ld", connect);
ASSERT(Rfifo == NULL);
gcCollect(&gc, &Rfifo);
char* lock_name = String(RUN_PATH "/%ld.lock", connect);
ASSERT(lock_name == NULL);
gcCollect(&gc, &lock_name);
ASSERT(-1 == creat(lock_name, 00600));
ASSERT(-1 == MkFifo(Rfifo));
char* answer = String("Status: 200 OK" NL NL);
ASSERT(answer == NULL);
gcCollect(&gc, &answer);
Write(1, answer, strlen(answer));
for (;;)
{
int Rfd = open(Rfifo, O_RDONLY | O_NONBLOCK, 0);
ASSERT(-1 == Rfd);
fd_set set;
FD_ZERO(&set);
FD_SET(Rfd, &set);
struct timeval t = { SEC_TO_PING, 0 };
int rd = select(Rfd + 1, &set, NULL, NULL, &t);
ASSERT(-1 == rd);
FD_CLR(Rfd, &set);
if (!rd)
{
errno = 0;
Write(STDOUT, "0", 1);
ASSERT(errno);
close(Rfd);
continue;
}
int n_read = 0;
size_t total = 0;
char buf[PIPE_BUF] = {'\0', };
errno = 0;
while((n_read = read(Rfd, buf, sizeof(buf) - 1)))
{
if(-1 == n_read)
{
if(errno == EINTR
|| errno == EAGAIN
|| errno == EWOULDBLOCK
|| errno == EPIPE)
{
errno = 0;
continue;
}
break;
}
errno = 0;
int n = Write(STDOUT, buf, n_read);
ASSERT(errno);
total += n;
}
close(Rfd);
}
unlink(Rfifo);
unlink(lock_name);
gcClean(gc);
}
int WriteCSSflatFiles(const char *WorkSetName, const char *basename)
{
FILE *ptr;
struct affiliationList *af = 0;
struct arrivalList *ar = 0;
struct assocList *as = 0;
struct eventList *ev = 0;
struct gregionList *gr = 0;
struct instrumentList *in = 0;
struct origerrList *oe = 0;
struct originList *orig = 0;
struct remarkList *re = 0;
struct sensorList *se = 0;
struct siteList *si = 0;
struct sitechanList *sc = 0;
struct stassocList *sa = 0;
struct wfdiscList *w = 0;
struct wftagList *wt = 0;
struct sacdataList *sd = 0;
DBlist tree;
char* FileName;
if(!basename || ! strlen(basename)){
css_error("Invalid basename.\n");
return 0;
}
if(!WorkSetName || !strlen(WorkSetName) ){
css_error("Invalid worksetname. Cannot write CSS binary data to file.\n");
return 0;
}
if(!smChangeDefaultWorksetByName( (char*)WorkSetName )){
css_error("Workset %s is empty orig does not exist\n", WorkSetName);
return 0;
}
tree = smGetDefaultTree();
if(!tree)return 0;
gcCollect ( tree ) ;
if(HasAffiliationStructs( tree ) ){
FileName = MakeFileName( basename, "affiliation");
if(! (ptr = fopen( FileName, "w" ) ) ){
css_error("Unable to open output file (%s)\n",FileName);
return 0;
}
do{
if(!(af = (struct affiliationList*) dblNextTableInstance(af, tree, dbl_LIST_AFFILIATION) ) ) break;
if(!WriteAffiliationRecord(af, ptr) ){
fclose(ptr);
free(FileName);
return 0;
}
}while(af);
fclose(ptr);
free(FileName);
}
if(HasArrivalStructs( tree ) ){
FileName = MakeFileName( basename, "arrival");
if(! (ptr = fopen( FileName, "w" ) ) ){
css_error("Unable to open output file (%s)\n",FileName);
return 0;
}
do{
if(!(ar = (struct arrivalList*) dblNextTableInstance(ar, tree, dbl_LIST_ARRIVAL) ) ) break;
if(!WriteArrivalRecord(ar, ptr) ){
fclose(ptr);
free(FileName);
return 0;
}
}while(ar);
fclose(ptr);
free(FileName);
}
if(HasAssocStructs( tree ) ){
FileName = MakeFileName( basename, "assoc");
if(! (ptr = fopen( FileName, "w" ) ) ){
css_error("Unable to open output file (%s)\n",FileName);
return 0;
}
do{
if(!(as = (struct assocList*) dblNextTableInstance(as, tree, dbl_LIST_ASSOC) ) ) break;
if(!WriteAssocRecord(as, ptr) ){
fclose(ptr);
free(FileName);
return 0;
}
}while(as);
fclose(ptr);
free(FileName);
}
if(HasEventStructs( tree ) ){
FileName = MakeFileName( basename, "event");
if(! (ptr = fopen( FileName, "w" ) ) ){
css_error("Unable to open output file (%s)\n",FileName);
return 0;
}
do{
if(!(ev = (struct eventList*) dblNextTableInstance(ev, tree, dbl_LIST_EVENT) ) ) break;
if(!WriteEventRecord(ev, ptr) ){
fclose(ptr);
free(FileName);
return 0;
}
}while(ev);
fclose(ptr);
free(FileName);
}
if(HasGregionStructs( tree ) ){
FileName = MakeFileName( basename, "gregion");
if(! (ptr = fopen( FileName, "w" ) ) ){
css_error("Unable to open output file (%s)\n",FileName);
return 0;
}
do{
if(!(gr = (struct gregionList*) dblNextTableInstance(gr, tree, dbl_LIST_GREGION) ) ) break;
if(!WriteGregionRecord(gr, ptr) ){
fclose(ptr);
free(FileName);
return 0;
}
}while(gr);
fclose(ptr);
free(FileName);
}
if(HasInstrumentStructs( tree ) ){
FileName = MakeFileName( basename, "instrument");
if(! (ptr = fopen( FileName, "w" ) ) ){
css_error("Unable to open output file (%s)\n",FileName);
return 0;
}
do{
if(!(in = (struct instrumentList*) dblNextTableInstance(in, tree, dbl_LIST_INSTRUMENT) ) ) break;
if(!WriteInstrumentRecord(in, ptr) ){
fclose(ptr);
free(FileName);
return 0;
}
}while(in);
fclose(ptr);
free(FileName);
}
if(HasOrigerrStructs( tree ) ){
FileName = MakeFileName( basename, "origerr");
if(! (ptr = fopen( FileName, "w" ) ) ){
css_error("Unable to open output file (%s)\n",FileName);
return 0;
}
do{
if(!(oe = (struct origerrList*) dblNextTableInstance(oe, tree, dbl_LIST_ORIGERR) ) ) break;
if(!WriteOrigerrRecord(oe, ptr) ){
fclose(ptr);
free(FileName);
return 0;
}
}while(oe);
fclose(ptr);
free(FileName);
}
if(HasOriginStructs( tree ) ){
FileName = MakeFileName( basename, "origin");
if(! (ptr = fopen( FileName, "w" ) ) ){
css_error("Unable to open output file (%s)\n",FileName);
return 0;
}
do{
if(!(orig = (struct originList*) dblNextTableInstance(orig, tree, dbl_LIST_ORIGIN) ) ) break;
if(!WriteOriginRecord(orig, ptr) ){
fclose(ptr);
free(FileName);
return 0;
}
}while(orig);
fclose(ptr);
free(FileName);
}
if(HasRemarkStructs( tree ) ){
FileName = MakeFileName( basename, "remark");
if(! (ptr = fopen( FileName, "w" ) ) ){
css_error("Unable to open output file (%s)\n",FileName);
return 0;
}
do{
if(!(re = (struct remarkList*) dblNextTableInstance(re, tree, dbl_LIST_REMARK) ) ) break;
if(!WriteRemarkRecord(re, ptr) ){
fclose(ptr);
free(FileName);
return 0;
}
}while(re);
fclose(ptr);
free(FileName);
}
if(HasSensorStructs( tree ) ){
FileName = MakeFileName( basename, "sensor");
if(! (ptr = fopen( FileName, "w" ) ) ){
css_error("Unable to open output file (%s)\n",FileName);
return 0;
}
do{
if(!(se = (struct sensorList*) dblNextTableInstance(se, tree, dbl_LIST_SENSOR) ) ) break;
if(!WriteSensorRecord(se, ptr) ){
fclose(ptr);
free(FileName);
return 0;
}
}while(se);
fclose(ptr);
free(FileName);
}
if(HasSiteStructs( tree ) ){
FileName = MakeFileName( basename, "site");
if(! (ptr = fopen( FileName, "w" ) ) ){
css_error("Unable to open output file (%s)\n",FileName);
return 0;
}
do{
if(!(si = (struct siteList*) dblNextTableInstance(si, tree, dbl_LIST_SITE) ) ) break;
if(!WriteSiteRecord(si, ptr) ){
fclose(ptr);
free(FileName);
return 0;
}
}while(si);
fclose(ptr);
free(FileName);
}
if(HasSitechanStructs( tree ) ){
FileName = MakeFileName( basename, "sitechan");
if(! (ptr = fopen( FileName, "w" ) ) ){
css_error("Unable to open output file (%s)\n",FileName);
return 0;
}
do{
if(!(sc = (struct sitechanList*) dblNextTableInstance(sc, tree, dbl_LIST_SITECHAN) ) ) break;
if(!WriteSitechanRecord(sc, ptr) ){
fclose(ptr);
free(FileName);
return 0;
}
}while(sc);
fclose(ptr);
free(FileName);
}
if(HasStassocStructs( tree ) ){
FileName = MakeFileName( basename, "stassoc");
if(! (ptr = fopen( FileName, "w" ) ) ){
css_error("Unable to open output file (%s)\n",FileName);
return 0;
}
do{
if(!(sa = (struct stassocList*) dblNextTableInstance(sa, tree, dbl_LIST_SITECHAN) ) ) break;
if(!WriteStassocRecord(sa, ptr) ){
fclose(ptr);
free(FileName);
return 0;
}
}while(sa);
fclose(ptr);
free(FileName);
}
if(HasWfdiscStructs( tree ) ){
FileName = MakeFileName( basename, "wfdisc");
if(! (ptr = fopen( FileName, "w" ) ) ){
css_error("Unable to open output file (%s)\n",FileName);
return 0;
}
do{
if(!(w = (struct wfdiscList*) dblNextTableInstance(w, tree, dbl_LIST_WFDISC) ) ) break;
if(!WriteWfdiscRecord(basename, w, ptr) ){
fclose(ptr);
free(FileName);
return 0;
}
}while(w);
fclose(ptr);
free(FileName);
}
if(HasWftagStructs( tree ) ){
FileName = MakeFileName( basename, "wftag");
if(! (ptr = fopen( FileName, "w" ) ) ){
css_error("Unable to open output file (%s)\n",FileName);
return 0;
}
do{
if(!(wt = (struct wftagList*) dblNextTableInstance(wt, tree, dbl_LIST_WFTAG) ) ) break;
if(!WriteWftagRecord(wt, ptr) ){
fclose(ptr);
free(FileName);
return 0;
}
}while(wt);
fclose(ptr);
free(FileName);
}
if(HasSacdataStructs( tree ) ){
FileName = MakeFileName( basename, "sacdata");
if(! (ptr = fopen( FileName, "w" ) ) ){
css_error("Unable to open output file (%s)\n",FileName);
return 0;
}
do{
if(!(sd = (struct sacdataList*) dblNextTableInstance(sd, tree, dbl_LIST_SACDATA) ) ) break;
if(!WriteSacdataRecord(sd, ptr) ){
fclose(ptr);
free(FileName);
return 0;
}
}while(sd);
fclose(ptr);
free(FileName);
}
return 1;
}
void
xcutim ( int *nerr )
{
/* declare variables */
char kcutSave[ 2 ][ 9 ] ,
defaultWorksetName[] = "workset01" ,
*worksetName = NULL ;
int i;
char *tmp;
double dtmp[2];
int idx , jdx , jdfl ,
nBounds ,
nOriginalFiles = cmdfm.ndfl ,
nSacFiles = 0 ,
refTimeType = IB ;
const int charsInBase = 9 ;
int lname = FALSE , lnotused , lcutSave ;
const int lcuttrue = TRUE ;
int nlen , ndx1 , ndx2 ;
float ocutSave[ 2 ] ;
double refTime ; /* subract this from the picks. */
DBlist tree ;
struct cutPair {
char kbase[ 2 ][ 9 ] ;
float offset[ 2 ] ;
} bounds[ MAXPAIRS ] ;
/* save current global values */
lcutSave = cmdfm.lcut ;
ocutSave[ 0 ] = cmdfm.ocut[ 0 ] ;
ocutSave[ 1 ] = cmdfm.ocut[ 1 ] ;
strcpy ( kcutSave[ 0 ] , kmdfm.kcut[ 0 ] ) ;
strcpy ( kcutSave[ 1 ] , kmdfm.kcut[ 1 ] ) ;
/* PARSING PHASE */
/* -- "COMMIT|RECALLTRACE|ROLLBACK":
how to treat existing data */
if ( lckeyExact ( "COMMIT" , 7 ) )
cmdfm.icomORroll = COMMIT ;
else if (lckeyExact ( "RECALLTRACE" , 12 ) )
cmdfm.icomORroll = RECALL ;
else if ( lckeyExact ( "RECALL" , 7 ) )
cmdfm.icomORroll = RECALL ;
else if ( lckeyExact ( "ROLLBACK" , 9 ) )
cmdfm.icomORroll = ROLLBACK ;
/* Get the limits of the cut. */
for ( nBounds = 0 ; nBounds < MAXPAIRS ; nBounds++ ) {
if ( !lcrtw ( &lnotused, (bounds[ nBounds ].kbase[0]), charsInBase, dtmp) ) {
break ;
} else {
bounds[ nBounds ].offset[0] = (float) dtmp[0];
bounds[ nBounds ].offset[1] = (float) dtmp[1];
}
if ( !strcmp ( bounds[ nBounds ].kbase [ 0 ] , "A " ) &&
!strcmp ( bounds[ nBounds ].kbase [ 1 ] , "F " ) ) {
break ;
}
} /* end for */
/* CHECKING PHASE */
/* - Check for null data file list. */
vflist( nerr );
if( *nerr != 0 )
return ;
/* - Check to make sure all files are evenly spaced time series files. */
vfeven( nerr );
if( *nerr != 0 )
return ;
/* Check that the resulting number of files won't exceed max */
if ( cmdfm.ndfl * nBounds > MDFL ) {
*nerr = 1403 ;
return ;
}
/* Check that cut point information is of the proper form. */
for ( idx = 0 ; idx < nBounds ; idx++ ) {
for ( jdx = 0 ; jdx < 2 ; jdx++ ) {
char *test = &( bounds[ idx ].kbase[ jdx ][ 0 ] ) ;
if ( *test != 'A' && /* first arrival */
*test != 'B' && /* begin time of trace */
*test != 'E' && /* end time of trace */
*test != 'F' && /* end of event */
*test != 'O' && /* origin */
*test != 'T' && /* zero seconds */
*test != 'Z' ) {
*nerr = 1405 ;
return ;
}
if ( *test == 'T' ) {
if ( !isdigit ( *(test+1) ) ) {
*nerr = 1405 ;
return ;
}
if ( strcmp ( test + 2 , " " ) ) {
*nerr = 1405 ;
return ;
}
} /* end if ( *test == 'T' ) */
else {
if ( strcmp ( test + 1 , " " ) ) {
*nerr = 1405 ;
return ;
}
}
}
} /* end for ( idx ) */
/* EXECUTION PHASE */
/* - Commit or rollback data according to lmore and cmdfm.icomORroll */
alignFiles ( nerr ) ;
if ( *nerr )
return ;
/* Get necessary SeisMgr information */
tree = smGetDefaultTree () ;
/* Remove all waveforms from Sacmem */
deleteAllSacFiles ( nerr , FALSE ) ; /* don't delete file names */
if ( *nerr )
return ;
/* set logical cut to TRUE */
cmdfm.lcut = TRUE ;
/* Loop between pairs of cut points */
for ( idx = 0 ; idx < nBounds ; idx++ ) {
struct wfdiscList *wfL = NULL ;
/* reset cut parameters. */
strcpy ( kmdfm.kcut[ 0 ] , bounds[ idx ].kbase[ 0 ] ) ;
strcpy ( kmdfm.kcut[ 1 ] , bounds[ idx ].kbase[ 1 ] ) ;
cmdfm.ocut[ 0 ] = bounds[ idx ].offset[ 0 ] ;
cmdfm.ocut[ 1 ] = bounds[ idx ].offset[ 1 ] ;
/* Loop between waveforms in SeisMgr */
do {
/* Get next waveform. */
if ( ! ( wfL = dblNextTableInstance ( wfL , tree , dbl_LIST_WFDISC ) ) )
break ;
/* Get the header to go with the waveform */
sacHeaderFromCSS( tree, &( globalSacHeader[ nSacFiles ] ),
wfL, refTimeType, &refTime, cmdfm.nMagSpec) ;
/* Get picks according to the preferences file and
pickauth and pickphase commands. */
nSacFiles++;
prefPicksToHeader( &( globalSacHeader[ nSacFiles ] ), nSacFiles,
wfL->element, tree, refTime, nerr ) ;
if ( *nerr ) {
setmsg ( "WARNING" , 1401 ) ;
outmsg () ;
clrmsg () ;
*nerr = 0 ;
}
if ( !lname && nSacFiles > nOriginalFiles )
lname = TRUE ;
/* Create a SAC file, fill the header and waveform. */
CSStoSAC( nSacFiles, &( globalSacHeader[ nSacFiles-1 ] ),
wfL->seis, lname , lcuttrue , nerr ) ;
if ( *nerr ) {
setmsg ( "WARNING" , 1402 ) ;
outmsg () ;
clrmsg () ;
*nerr = 0 ;
}
} while ( wfL ) ; /* End loop between waveforms in SeisMgr */
} /* End loop between pairs of cut points. */
/* Make nBounds copies of sac filenames */
for ( idx = 1 ; idx < nBounds ; idx++ ) {
for(i = 0; i < nOriginalFiles; i++) {
tmp = string_list_get(datafiles, i);
string_list_put(datafiles, tmp, strlen(tmp));
}
}
/* Set global number of files */
cmdfm.ndfl = nSacFiles ;
/* Remove all waveforms from SeisMgr */
/*smDeleteDefaultTree() ;*/
worksetName = smGetDefaultWorksetName () ;
if ( worksetName )
smDeleteWorksetByName ( worksetName ) ;
else
worksetName = defaultWorksetName ;
/* Read each waveform from Sacmem back to SeisMgr */
for ( jdfl = 1 ; jdfl <= nSacFiles ; jdfl++ ) {
sacSACdata newData ;
getfil ( jdfl , FALSE , &nlen , &ndx1 , &ndx2 , nerr ) ;
if ( *nerr ) {
*nerr = 1406 ;
goto L_ERROR ;
}
newData.dataType = globalSacHeader[ jdfl - 1 ].iftype ;
newData.xarray = cmmem.sacmem[ cmdfm.ndxdta[ jdfl - 1 ][ 1 ] ] ;
newData.yarray = cmmem.sacmem[ cmdfm.ndxdta[ jdfl - 1 ][ 0 ] ] ;
globalSacHeader[ jdfl-1 ].b = *begin ;
globalSacHeader[ jdfl-1 ].e = *ennd ;
globalSacHeader[ jdfl-1 ].npts = *npts ;
sacLoadFromHeaderAndData( &( globalSacHeader[ jdfl-1 ] ) , &newData ,
worksetName , FALSE , jdfl-1 , TRUE , TRUE ) ;
} /* end for ( jdfl ) */
/* clean up garbage in SeisMgr */
tree = smGetDefaultTree () ;
gcCollect ( tree ) ;
/* Make sure to reset global cut values whether the command worked or not. */
L_ERROR:
cmdfm.lcut = lcutSave ;
cmdfm.ocut[ 0 ] = ocutSave[ 0 ] ;
cmdfm.ocut[ 1 ] = ocutSave[ 1 ] ;
strcpy ( kmdfm.kcut[ 0 ] , kcutSave[ 0 ] ) ;
strcpy ( kmdfm.kcut[ 1 ] , kcutSave[ 1 ] ) ;
} /* end xcutim() */
