/*-------------------------------------------------------------------------
* Function: lite_PD_copy_syment
*
* Purpose: Make and return a copy of the given syment.
*
* Return: Success: a new syment
*
* Failure:
*
* Programmer: Adapted from PACT PDB
* Mar 6, 1996 11:39 AM EST
*
* Modifications:
* Eric Brugger, Tue Dec 8 15:16:07 PST 1998
* Remove unnecessary calls to lite_SC_mark, since reference count now
* set when allocated.
*
*-------------------------------------------------------------------------
*/
syment *
lite_PD_copy_syment (syment *osym) {
int i, n;
char *ntype;
syment *nsym;
symblock *nsp, *osp;
dimdes *ndims;
if (osym == NULL) return(NULL);
nsym = FMAKE(syment, "PD_COPY_SYMENT:nsym");
n = PD_n_blocks(osym);
osp = PD_entry_blocks(osym);
nsp = FMAKE_N(symblock, n, "PD_COPY_SYMENT:blocks");
for (i = 0; i < n; i++) nsp[i] = osp[i];
ntype = lite_SC_strsavef(PD_entry_type(osym),
"char*:PD_COPY_SYMENT:type");
ndims = lite_PD_copy_dims(PD_entry_dimensions(osym));
PD_entry_blocks(nsym) = nsp;
PD_entry_type(nsym) = ntype;
PD_entry_dimensions(nsym) = ndims;
PD_entry_number(nsym) = PD_entry_number(osym);
PD_entry_indirects(nsym) = PD_entry_indirects(osym);
return(nsym);
}
/*-------------------------------------------------------------------------
* Function: lite_PD_read_as_alt
*
* Purpose: Read part of an entry from the PDB file pointed to by the
* symbol table into the location pointed to by VR. IND contains
* one triplet of long ints per variable dimension specifying
* start, stop, and step for the index.
*
* Note: The entry must be an array (either a static array or
* a pointer)
*
* Note: VR must be a pointer to an object with the type of
* the object associated with NAME (PDBLib will allocate space
* if necessary)!
*
* Return: Success: Number of items successfully read.
*
* Failure: 0
*
* Programmer: Adapted from PACT PDB
* Mar 4, 1996 11:49 AM EST
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int
lite_PD_read_as_alt (PDBfile *file, char *name, char *type, lite_SC_byte *vr,
long *ind) {
char fullpath[MAXLINE];
dimdes *pd, *dims;
syment *ep;
int nd;
switch (setjmp(_lite_PD_read_err)) {
case ABORT:
return(FALSE);
case ERR_FREE:
return(TRUE);
default:
memset(lite_PD_err, 0, MAXLINE);
break;
}
/*
* Look up the variable name and return FALSE if it is not there.
*/
ep = _lite_PD_effective_ep(file, name, TRUE, fullpath);
if (ep == NULL)
lite_PD_error("ENTRY NOT IN SYMBOL TABLE - PD_READ_AS_ALT", PD_READ);
dims = PD_entry_dimensions(ep);
for (nd = 0, pd = dims; pd != NULL; pd = pd->next, nd++) /*void*/ ;
return _lite_PD_indexed_read_as (file, fullpath, type, vr, nd, ind, ep);
}
/*-------------------------------------------------------------------------
* Function: _lite_PD_rl_syment_d
*
* Purpose: Reclaim the space of the given syment including its
* dimensions.
*
* Return: void
*
* Programmer: Adapted from PACT PDB
* Mar 5, 1996 12:06 PM EST
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
void
_lite_PD_rl_syment_d (syment *ep) {
if (ep == NULL) return;
_lite_PD_rl_dimensions(PD_entry_dimensions(ep));
_lite_PD_rl_syment(ep);
}
/*-------------------------------------------------------------------------
* Function: _lite_PD_mk_syment
*
* Purpose: Make and return a pointer to an entry for the symbol table.
*
* Return: Success:
*
* Failure:
*
* Programmer: Adapted from PACT PDB
* Mar 5, 1996 2:16 PM EST
*
* Modifications:
* Eric Brugger, Tue Dec 8 15:16:07 PST 1998
* Remove unnecessary calls to lite_SC_mark, since reference count now
* set when allocated.
*
*-------------------------------------------------------------------------
*/
syment *
_lite_PD_mk_syment (char *type, long numb, long addr,
symindir *indr, dimdes *dims) {
syment *ep;
symblock *sp;
char *t;
ep = FMAKE(syment, "_PD_MK_SYMENT:ep");
sp = FMAKE(symblock, "_PD_MK_SYMENT:sp");
PD_entry_blocks(ep) = sp;
sp->number = numb;
sp->diskaddr = addr;
if (type == NULL) {
t = NULL;
} else {
t = lite_SC_strsavef(type, "char*:_PD_MK_SYMENT:type");
}
PD_entry_type(ep) = t;
PD_entry_number(ep) = numb;
PD_entry_dimensions(ep) = dims;
if (indr == NULL) {
symindir iloc;
iloc.addr = 0L;
iloc.n_ind_type = 0L;
iloc.arr_offs = 0L;
PD_entry_indirects(ep) = iloc;
} else {
PD_entry_indirects(ep) = *indr;
}
return(ep);
}
bool
PDBFileObject::SymbolExists(const char *name, TypeEnum *t,
std::string &typeString, int *nTotalElements, int **dimensions,
int *nDims)
{
bool retval = false;
syment *ep = 0;
// Indicate that there is no type initially.
if (t)
*t = NO_TYPE;
if (nTotalElements)
*nTotalElements = 0;
if (dimensions)
*dimensions = 0;
if (nDims)
*nDims = 0;
if(AutoOpen())
{
if((ep = PD_inquire_entry(pdb, (char *)name, 0, NULL)) != NULL)
{
dimdes *dimptr = NULL;
int i = 0, nd = 0, length = 1;
int *dims = 0;
// Return the actual name of type
typeString = PD_entry_type(ep);
// Figure out the number of dimensions and the number of elements
// that are in the entire array.
dimptr = PD_entry_dimensions(ep);
if(dimptr != NULL)
{
// Figure out the number of dimensions.
while(dimptr != NULL)
{
length *= dimptr->number;
dimptr = dimptr->next;
++nd;
}
// Store the dimensions of the array.
dims = new int[nd];
dimptr = PD_entry_dimensions(ep);
while(dimptr != NULL)
{
dims[i++] = dimptr->number;
dimptr = dimptr->next;
}
}
else
{
dims = new int[1];
dims[0] = 1;
}
// Print the dimensions to the debug log.
debug4 << "PDBFileObject::SymbolExists: name=" << name << ", dimensions={";
for(i = 0; i < nd; ++i)
debug4 << dims[i] << ", ";
debug4 << "}" << endl;
// Set some of the return values.
if (dimensions)
*dimensions = dims;
if (nDims)
*nDims = nd;
if (nTotalElements)
*nTotalElements = length;
//
// Take the storage type along with the length to determine the real
// type that we want to report.
//
if (t)
{
if(strcmp(PD_entry_type(ep), "char") == 0 ||
strcmp(PD_entry_type(ep), "string") == 0)
*t = (length > 1) ? CHARARRAY_TYPE : CHAR_TYPE;
else if(strcmp(PD_entry_type(ep), "short") == 0)
*t = (length > 1) ? SHORTARRAY_TYPE : SHORT_TYPE;
else if(strcmp(PD_entry_type(ep), "int") == 0 ||
strcmp(PD_entry_type(ep), "integer") == 0)
*t = (length > 1) ? INTEGERARRAY_TYPE : INTEGER_TYPE;
else if(strcmp(PD_entry_type(ep), "float") == 0)
*t = (length > 1) ? FLOATARRAY_TYPE : FLOAT_TYPE;
else if(strcmp(PD_entry_type(ep), "double") == 0)
*t = (length > 1) ? DOUBLEARRAY_TYPE : DOUBLE_TYPE;
else if(strcmp(PD_entry_type(ep), "long") == 0)
*t = (length > 1) ? LONGARRAY_TYPE : LONG_TYPE;
else
{
*t = OBJECT_TYPE;
}
}
retval = true;
}
}
return retval;
}
int main(int argc, char** argv)
{
if(argc < 4) {
fprintf(stderr, "Useage: %s <input file> <output file> <t stride>\n", argv[0]);
return 1;
}
int tstride;
if(sscanf(argv[3], "%d", &tstride) != 1) {
fprintf(stderr, "\tERROR: t stride must be an integer\n");
return 1;
}
// Open input file
PDBfile *in;
if((in = PD_open(argv[1], "r")) == NULL) {
fprintf(stderr, "\tERROR: Could not open input file '%s'\n", argv[1]);
return 1;
}
// Open output file
PDBfile *out;
if((out = PD_open(argv[2], "w")) == NULL) {
fprintf(stderr, "\tERROR: Could not open output file '%s'\n", argv[2]);
return 1;
}
// Get list of variables
int nvars;
char **var_names = PD_ls(in, NULL, NULL, &nvars);
if((var_names == (char**) NULL) || (nvars < 1)) {
fprintf(stderr, "\tERROR: No variables\n");
return 1;
}
// Go through the variables
char *varname;
for(int var=0;var<nvars;var++) {
varname = var_names[var];
syment *ep; // PDB query types
dimdes* dims;
// Query size of the variable
if((ep = PD_query_entry(in, varname, NULL)) == (syment*) NULL) {
fprintf(stderr, "\tError querying variable %s\n", varname);
return 1;
}
dims = PD_entry_dimensions(ep);
int nd = 0; // Count number of dimensions
int varsize = 1; // Number of elements
long inds[12];
while(dims != (dimdes*) NULL) {
long min, max;
min = dims->index_min;
max = dims->index_max;
if(nd > 3) {
fprintf(stderr, "\tERROR: Can't handle variable '%s': more than 4D\n", varname);
return 2;
}
inds[3*nd] = min; inds[3*nd + 1] = max; inds[3*nd + 2] = 1L;
varsize *= max - min + 1;
nd++;
dims = dims->next;
}
// Get variable type
char *typ;
typ = PD_entry_type(ep);
if((strcmp(varname, "t_array") == 0) && (nd == 1)) {
float *fdata = new float[varsize];
// Read the data from the PDB file
inds[2] = tstride;
int nread;
if( (nread = PD_read_as_alt(in, varname, "float", fdata, inds)) == 0) {
fprintf(stderr, "\tWARNING: Could not read t_array. Ignoring\n");
delete[] fdata;
continue;
}
inds[0] = 0L;
inds[1] = nread-1;
inds[2] = 1L;
if(PD_write_alt(out, varname, "float", fdata, 1, inds) == FALSE) {
fprintf(stderr, "\tWARNING: Could not write '%s'. Ignoring\n", varname);
}
delete[] fdata;
}else if(nd == 4) {
// Reducing time resolution
if(strcasecmp(typ, "integer") == 0) {
int *idata = new int[varsize];
// Read the data from the PDB file
inds[2] = tstride;
int nread;
if( (nread = PD_read_as_alt(in, varname, "integer", idata, inds)) == 0) {
fprintf(stderr, "\tWARNING: Could not read '%s'. Ignoring\n", varname);
delete[] idata;
continue;
}
if( nread % (varsize / (inds[1] - inds[0] + 1)) != 0 ) {
fprintf(stderr, "ERROR: Accounting error: (%ld, %ld), %d, %d\n", inds[0], inds[1], varsize, nread);
delete[] idata;
continue;
}
nread = nread / (varsize / (inds[1] - inds[0] + 1));
inds[0] = 0L;
inds[1] = nread - 1;
inds[2] = 1L;
if(PD_write_alt(out, varname, "integer", idata, 4, inds) == FALSE) {
fprintf(stderr, "\tWARNING: Could not write '%s'. Ignoring\n", varname);
}
delete[] idata;
}else if( (strcasecmp(typ, "float") == 0) ||
(strcasecmp(typ, "double") == 0) ) {
// Convert doubles to floats
float *fdata = new float[varsize];
// Read the data from the PDB file
inds[2] = tstride;
int nread;
if( (nread = PD_read_as_alt(in, varname, "float", fdata, inds)) == 0) {
fprintf(stderr, "\tWARNING: Could not read '%s'. Ignoring\n", varname);
delete[] fdata;
continue;
}
if( nread % (varsize / (inds[1] - inds[0] + 1)) != 0 ) {
fprintf(stderr, "ERROR: Accounting error: (%ld, %ld), %d, %d\n", inds[0], inds[1], varsize, nread);
delete[] fdata;
continue;
}
nread = nread / (varsize / (inds[1] - inds[0] + 1));
inds[0] = 0L;
inds[1] = nread - 1;
inds[2] = 1L;
if(PD_write_alt(out, varname, "float", fdata, 4, inds) == FALSE) {
fprintf(stderr, "\tWARNING: Could not write '%s'. Ignoring\n", varname);
}
delete[] fdata;
}else {
fprintf(stderr, "\tWARNING: '%s' has unrecognised type '%s'. Ignoring\n", varname, typ);
}
}else {
// Just copy the data across
if(strcasecmp(typ, "integer") == 0) {
int *idata = new int[varsize];
// Read the data from the PDB file
if (PD_read_as(in, varname, "integer", idata) == 0) {
fprintf(stderr, "\t\tWARNING: Could not read variable. Ignoring\n");
delete[] idata;
continue;
}
if(PD_write_alt(out, varname, "integer", idata, nd, inds) == FALSE) {
fprintf(stderr, "\tWARNING: Could not write variable '%s'\n", varname);
}
delete[] idata;
}else if( (strcasecmp(typ, "float") == 0) ||
(strcasecmp(typ, "double") == 0) ) {
// Convert doubles to floats
float *fdata = new float[varsize];
// Read the data from the PDB file
if (PD_read_as(in, varname, "float", fdata) == 0) {
fprintf(stderr, "\tWARNING: Could not read variable '%s'. Ignoring\n", varname);
delete[] fdata;
continue;
}
if(PD_write_alt(out, varname, "float", fdata, nd, inds) == FALSE) {
fprintf(stderr, "\tWARNING: Could not write variable '%s'\n", varname);
}
delete[] fdata;
}else {
fprintf(stderr, "WARNING: '%s' has unrecognised type '%s'. Ignoring\n", varname, typ);
}
}
}
PD_close(in);
PD_close(out);
return 0;
}
