void
read_descriptrace( FILE *fp, Suds_tag header, Suds_descriptrace *d, int swap, long **data, int *bufsiz ) {
fread( &d->dt_name.network, sizeof( char ), 4, fp );
fread( &d->dt_name.st_name, sizeof( char ), 5, fp );
fread( &d->dt_name.component, sizeof( char ), 1, fp );
fread( &d->dt_name.inst_type, sizeof( short ), 1, fp );
fread( &d->begintime, sizeof( double ), 1, fp );
fread( &d->localtime, sizeof( short ), 1, fp );
fread( &d->datatype, sizeof( char ), 1, fp );
fread( &d->descriptor, sizeof( char ), 1, fp );
fread( &d->digi_by, sizeof( short ), 1, fp );
fread( &d->processed, sizeof( short ), 1, fp );
fread( &d->length, sizeof( long ), 1, fp );
fread( &d->rate, sizeof( float ), 1, fp );
fread( &d->mindata, sizeof( float ), 1, fp );
fread( &d->maxdata, sizeof( float ), 1, fp );
fread( &d->avenoise, sizeof( float ), 1, fp );
fread( &d->numclip, sizeof( long ), 1, fp );
fread( &d->time_correct, sizeof( double ), 1, fp );
fread( &d->rate_correct, sizeof( float ), 1, fp );
if( swap ) {
swap2( &d->dt_name.inst_type, &d->dt_name.inst_type, 1 );
swap8( &d->begintime, &d->begintime, 1 );
swap2( &d->localtime, &d->localtime, 1 );
swap2( &d->digi_by, &d->digi_by, 1 );
swap2( &d->processed, &d->processed, 1 );
swap4( &d->length, &d->length, 1 );
swap4( &d->rate, &d->rate, 1 );
swap4( &d->mindata, &d->mindata, 1 );
swap4( &d->maxdata, &d->maxdata, 1 );
swap4( &d->avenoise, &d->avenoise, 1 );
swap4( &d->numclip, &d->numclip, 1 );
swap8( &d->time_correct, &d->time_correct, 1 );
swap4( &d->rate_correct, &d->rate_correct, 1 );
}
if( d->datatype != '2' ) {
complain( 1, "Datatype %s not understood--skipping\n", d->datatype );
fseek( fp, header.data_length_bytes, SEEK_CUR );
} else {
if( *bufsiz < header.data_length_bytes ) {
reallot( long *, *data, d->length );
*bufsiz = d->length * sizeof( long );
}
fread( *data, sizeof( long ), d->length, fp );
if( swap ) {
swap4( *data, *data, d->length );
}
}
void
read_stationcomp( FILE *fp, Suds_tag header, Suds_stationcomp *s, int swap ) {
fread( &s->sc_name.network, sizeof( char ), 4, fp );
fread( &s->sc_name.st_name, sizeof( char ), 5, fp );
fread( &s->sc_name.component, sizeof( char ), 1, fp );
fread( &s->sc_name.inst_type, sizeof( short ), 1, fp );
fread( &s->azim, sizeof( short ), 1, fp );
fread( &s->incid, sizeof( short ), 1, fp );
fread( &s->st_lat, sizeof( double ), 1, fp );
fread( &s->st_long, sizeof( double ), 1, fp );
fread( &s->elev, sizeof( float ), 1, fp );
fread( &s->enclosure, sizeof( char ), 1, fp );
fread( &s->annotation, sizeof( char ), 1, fp );
fread( &s->recorder, sizeof( char ), 1, fp );
fread( &s->rockclass, sizeof( char ), 1, fp );
fread( &s->rocktype, sizeof( short ), 1, fp );
fread( &s->sitecondition, sizeof( char ), 1, fp );
fread( &s->sensor_type, sizeof( char ), 1, fp );
fread( &s->data_type, sizeof( char ), 1, fp );
fread( &s->data_units, sizeof( char ), 1, fp );
fread( &s->polarity, sizeof( char ), 1, fp );
fread( &s->st_status, sizeof( char ), 1, fp );
fread( &s->max_gain, sizeof( float ), 1, fp );
fread( &s->clip_value, sizeof( float ), 1, fp );
fread( &s->con_mvolts, sizeof( float ), 1, fp );
fread( &s->channel, sizeof( short ), 1, fp );
fread( &s->atod_gain, sizeof( short ), 1, fp );
fread( &s->effective, sizeof( long ), 1, fp );
fread( &s->clock_correct, sizeof( float ), 1, fp );
fread( &s->station_delay, sizeof( float ), 1, fp );
if( swap ) {
swap2( &s->sc_name.inst_type, &s->sc_name.inst_type, 1 );
swap2( &s->azim, &s->azim, 1 );
swap2( &s->incid, &s->incid, 1 );
swap8( &s->st_lat, &s->st_lat, 1 );
swap8( &s->st_long, &s->st_long, 1 );
swap4( &s->elev, &s->elev, 1 );
swap2( &s->rocktype, &s->rocktype, 1 );
swap4( &s->max_gain, &s->max_gain, 1 );
swap4( &s->clip_value, &s->clip_value, 1 );
swap4( &s->con_mvolts, &s->con_mvolts, 1 );
swap2( &s->channel, &s->channel, 1 );
swap2( &s->atod_gain, &s->atod_gain, 1 );
swap4( &s->effective, &s->effective, 1 );
swap4( &s->clock_correct, &s->clock_correct, 1 );
swap4( &s->station_delay, &s->station_delay, 1 );
}
fseek( fp, header.data_length_bytes, SEEK_CUR );
}
/*
* byteswap a single magic entry
*/
static void bs1(struct r_magic *m) {
m->cont_level = swap2(m->cont_level);
m->offset = swap4((ut32)m->offset);
m->in_offset = swap4((ut32)m->in_offset);
m->lineno = swap4((ut32)m->lineno);
if (MAGIC_IS_STRING (m->type)) {
m->str_range = swap4(m->str_range);
m->str_flags = swap4(m->str_flags);
} else {
m->value.q = swap8(m->value.q);
m->num_mask = swap8(m->num_mask);
}
}
static void rc4(const uint8_t *key, size_t keylen, uint8_t *xorbuf, size_t xorbuflen)
{
uint8_t S[256];
for (unsigned i = 0; i < 256; i++)
S[i] = i;
for (unsigned i = 0, j = 0; i < 256; i++)
{
j = (j + S[i] + key[i % keylen]) & 0xff;
swap8(S + i, S + j);
}
for (unsigned i = 0, j = 0, n = 0; n < xorbuflen; n++)
{
i = (i + 1) & 0xff;
j = (j + S[i]) & 0xff;
swap8(S + i, S + j);
xorbuf[n] ^= S[(S[i] + S[j]) & 0xff];
}
}
static int nextPerm(uint8_t n[], int count)
{
int tail, i, j;
if (count <= 1)
return 0;
for (i = count - 1; i>0 && n[i - 1] >= n[i]; i--);
tail = i;
if (tail > 0) {
for (j = count - 1; j>tail && n[j] <= n[tail - 1]; j--);
swap8(&n[tail - 1], &n[j]);
}
for (i = tail, j = count - 1; i<j; i++, j--)
swap8(&n[i], &n[j]);
return (tail != 0);
}
static istream &
utPortableRead(istream &is, char *dest, int numelem, int elemsize)
{
int size = numelem*elemsize;
char *buf = utGetBuffer(size);
int i;
ut_2byte *src2byte, *dest2byte;
ut_4byte *src4byte, *dest4byte;
ut_8byte *src8byte, *dest8byte;
switch(elemsize)
{
case 1:
is.read(dest, numelem);
break;
case 2:
src2byte = (ut_2byte *)buf;
dest2byte = (ut_2byte *)dest;
if (!buf) return is.read(dest, size);
is.read(buf, size);
for (i = 0; i < numelem; i++)
dest2byte[i] = swap2(src2byte[i]);
break;
case 4:
src4byte = (ut_4byte *)buf;
dest4byte = (ut_4byte *)dest;
if (!buf) return is.read(dest, size);
is.read(buf, size);
for (i = 0; i < numelem; i++)
dest4byte[i] = swap4(src4byte[i]);
break;
case 8:
src8byte = (ut_8byte *)buf;
dest8byte = (ut_8byte *)dest;
if (!buf) return is.read(dest, size);
is.read(buf, size);
for (i = 0; i < numelem; i++)
dest8byte[i] = swap8(src8byte[i]);
break;
}
return is;
}
static int
utPortableFWrite(FILE *f, const void *src, int numelem, int elemsize)
{
int size = numelem*elemsize;
char *buf = utGetBuffer(size);
int i, retval;
ut_2byte *src2byte, *dest2byte;
ut_4byte *src4byte, *dest4byte;
ut_8byte *src8byte, *dest8byte;
switch(elemsize)
{
case 1:
retval = fwrite(src, elemsize, numelem, f);
break;
case 2:
src2byte = (ut_2byte *)src;
dest2byte = (ut_2byte *)buf;
if (!buf) return fwrite(src, elemsize, numelem, f);
for (i = 0; i < numelem; i++)
dest2byte[i] = swap2(src2byte[i]);
retval = fwrite(buf, elemsize, numelem, f);
break;
case 4:
src4byte = (ut_4byte *)src;
dest4byte = (ut_4byte *)buf;
if (!buf) return fwrite(src, elemsize, numelem, f);
for (i = 0; i < numelem; i++)
dest4byte[i] = swap4(src4byte[i]);
retval = fwrite(buf, elemsize, numelem, f);
break;
case 8:
src8byte = (ut_8byte *)src;
dest8byte = (ut_8byte *)buf;
if (!buf) return fwrite(src, elemsize, numelem, f);
for (i = 0; i < numelem; i++)
dest8byte[i] = swap8(src8byte[i]);
retval = fwrite(buf, elemsize, numelem, f);
break;
}
return retval;
}
static ostream &
utPortableWrite(ostream &os, const char *src, int numelem, int elemsize)
{
int size = numelem*elemsize;
char *buf = utGetBuffer(size);
int i;
ut_2byte *src2byte, *dest2byte;
ut_4byte *src4byte, *dest4byte;
ut_8byte *src8byte, *dest8byte;
switch(elemsize)
{
case 1:
os.write(src, numelem);
break;
case 2:
src2byte = (ut_2byte *)src;
dest2byte = (ut_2byte *)buf;
if (!buf) return os.write(src, size);
for (i = 0; i < numelem; i++)
dest2byte[i] = swap2(src2byte[i]);
os.write(buf, size);
break;
case 4:
src4byte = (ut_4byte *)src;
dest4byte = (ut_4byte *)buf;
if (!buf) return os.write(src, size);
for (i = 0; i < numelem; i++)
dest4byte[i] = swap4(src4byte[i]);
os.write(buf, size);
break;
case 8:
src8byte = (ut_8byte *)src;
dest8byte = (ut_8byte *)buf;
if (!buf) return os.write(src, size);
for (i = 0; i < numelem; i++)
dest8byte[i] = swap8(src8byte[i]);
os.write(buf, size);
break;
}
return os;
}
static int
specadj(char *specsum)
{
FILE *f;
KeyWord *kw, *kw0;
KwpHead head;
Kwpack *p, *p0;
Kwpack0 *q;
Uint *u, *u0;
const char *strtab;
double *d, *fptab;
int swap;
size_t L, L1;
f = fopen(specsum, "rb");
if (!f) {
fprintf(stderr, "%s: cannot open \"%s\"\n", progname, specsum);
return 1;
}
fread(&head, sizeof(head), 1, f);
swap = 0;
if (head.bkind != 0x1234abcd) {
swap4(&head.bkind);
if (head.bkind != 0x1234abcd) {
badfile:
fprintf(stderr, "%s: invalid specsum file \"%s\"\n",
progname, specsum);
return 1;
}
swap8(&head.fpkind);
swap = 1;
swap4(&head.nkw);
swap4(&head.strtab_offset);
swap4(&head.kw_offset);
swap4(&head.end_offset);
}
if (head.fpkind != 1e13)
goto badfile;
L = head.end_offset;
L1 = head.kw_offset + (head.nkw+1)*sizeof(KeyWord);
if (L1 < L)
L1 = L;
fptab = (double*)Malloc(L1);
fread(fptab, L, 1, f);
fclose(f);
p = p0 = (Kwpack*)((char*)fptab + head.kw_offset);
strtab = (const char*)fptab + head.strtab_offset;
kw0 = (KeyWord*)p;
kw = ++kw0 + head.nkw;
p += head.nkw;
if (head.pad == 0) {
q = (Kwpack0*)p0 + head.nkw;
p = (Kwpack*)q;
}
if (swap) {
u0 = (Uint*)p0;
u = (Uint*)p;
while(u > u0)
swap4(--u);
d = fptab + head.strtab_offset/sizeof(double);
while(d > fptab)
swap8(--d);
}
if (head.pad == 0)
while(kw > kw0) { /* no DYNLIB data */
--kw;
--q;
kw->name = q->name ? strtab + q->name : 0;
kw->kind = q->kind;
kw->nkw = q->nkw;
kw->alt = q->alt;
kw->req = q->req;
kw->kw = q->kw ? kw0 + q->kw : 0;
kw->Lb = fptab[q->Lb];
kw->Ub = fptab[q->Ub];
kw->paoff = q->poff;
kw->f.start = kw->f.final = 0;
kw->f.vs = kw->f.vf = 0;
kw->comment = 0;
kw->kwnext = 0;
}
else
while(kw > kw0) {
uint32 MultiFileProcJobs( TUPLE_VIEWSIZE *tuplesAndSizes,
uint32 nViews,
ADC_VIEW_CNTL *avp ){
uint32 i;
int32 ii; /* it should be int */
uint32 j;
uint32 pn;
uint32 direction = 0;
uint32 dChange = 0;
uint32 gbi;
uint32 maxn;
uint64 *gbuf;
uint64 vszs[MAX_NUMBER_OF_TASKS];
uint32 nGroupbys[MAX_NUMBER_OF_TASKS];
TUPLE_ONES *toptr;
gbuf = (uint64*) &avp->memPool[0];
for(i = 0; i < avp->nTasks; i++ ){ nGroupbys[i] = 0; vszs[i] = 0; }
for(pn = 0, gbi = 0, ii = nViews-1; ii >= 0; ii-- ){
if(pn == avp->taskNumber) gbuf[gbi++]=tuplesAndSizes[ii].tuple;
nGroupbys[pn]++;
vszs[pn] += tuplesAndSizes[ii].viewsize;
if(direction == 0 && pn == avp->nTasks-1 ) {
direction = 1;
dChange = 1;
}
if(direction == 1 && pn == 0 ){
direction = 0;
dChange = 1;
}
if (!dChange){ if (direction) pn--; else pn++;}
dChange = 0;
}
for(maxn = 0, i = 0; i < avp->nTasks; i++)
if (nGroupbys[i] > maxn) maxn = nGroupbys[i];
toptr = (TUPLE_ONES*) malloc(sizeof(TUPLE_ONES)*maxn);
if(!toptr) return 1;
for(i = 0; i < avp->nTasks; i++ ){
if(i == avp->taskNumber){
for(j = 0; j < nGroupbys[i]; j++ ){
toptr[j].tuple = gbuf[j];
toptr[j].nOnes = countTupleOnes(gbuf[j], avp->nTopDims);
}
qsort((void*)gbuf, nGroupbys[i], 8, Comp8gbuf );
onessort(toptr, nGroupbys[i]);
for(j = 0; j < nGroupbys[i]; j++){
toptr[nGroupbys[i]-1-j].tuple <<= (64-avp->nTopDims);
swap8(&toptr[nGroupbys[i]-1-j].tuple);
fwrite(&toptr[nGroupbys[i]-1-j].tuple, 8, 1, avp->groupbyFile);
}
}
}
FSEEK(avp->groupbyFile, 0L, SEEK_SET);
if (toptr) free(toptr);
return 0;
}
long long mythen::stringToInt64(char *str)
{
long long value = *reinterpret_cast<long long*>(str);
if (isBigEndian_) swap8((char *)&value);
return value;
}
