void smurf_jsatileinfo( int *status ) {
/* Local Variables */
AstCmpRegion *overlap;
AstFitsChan *fc;
AstFrameSet *fs;
AstObject *obj;
AstRegion *region;
AstRegion *target;
HDSLoc *cloc = NULL;
HDSLoc *xloc = NULL;
char *jcmt_tiles;
char *tilendf = NULL;
char text[ 200 ];
double dec[ 8 ];
double dist;
double dlbnd[ 2 ];
double dubnd[ 2 ];
double gx[ 8 ];
double gy[ 8 ];
double maxdist;
double norm_radec[2];
double point1[ 2 ];
double point2[ 2 ];
double ra[ 8 ];
double ra0;
double dec0;
int *ipntr;
int axes[ 2 ];
int create;
int dirlen;
int el;
int exists;
int flag;
int i;
int indf1;
int indf2;
int indf3;
int itile;
int iv;
int jtile;
int lbnd[ 2 ];
int local_origin;
int nc;
int place;
int tlbnd[ 2 ];
int tubnd[ 2 ];
int ubnd[ 2 ];
smf_jsaproj_t proj;
int xt;
int yt;
smfJSATiling skytiling;
void *pntr;
/* Check inherited status */
if( *status != SAI__OK ) return;
/* Start a new AST context. */
astBegin;
/* Get the instrument to use abnd get the parameters describing the
layout of its JSA tiles. */
smf_jsainstrument( "INSTRUMENT", NULL, SMF__INST_NONE, &skytiling,
status );
/* Return the maximum tile index. */
parPut0i( "MAXTILE", skytiling.ntiles - 1, status );
/* Abort if an error has occurred. */
if( *status != SAI__OK ) goto L999;
/* Decide what sort of projection to use. */
parChoic( "PROJ", "HPX", "HPX,HPX12,XPHN,XPHS", 1, text, sizeof(text),
status );
proj = smf_jsaproj_fromstr( text, 1, status );
/* If required, create an all-sky NDF in which each pixel covers the area
of a single tile, and holds the integer tile index. The NDF has an
initial size of 1x1 pixels, but is expanded later to the required size. */
lbnd[ 0 ] = ubnd[ 0 ] = lbnd[ 1 ] = ubnd[ 1 ] = 1;
ndfCreat( "ALLSKY", "_INTEGER", 2, lbnd, ubnd, &indf3, status );
/* If a null (!) value was supplied for parameter ALLSKY, annull the
error and pass on. */
if( *status == PAR__NULL ) {
errAnnul( status );
/* Otherwise, create a FrameSet describing the whole sky in which each
pixel corresponds to a single tile. */
} else {
smf_jsatile( -1, &skytiling, 0, proj, NULL, &fs, NULL, lbnd, ubnd,
status );
/* Change the bounds of the output NDF. */
ndfSbnd( 2, lbnd, ubnd, indf3, status );
/* Store the FrameSet in the NDF. */
ndfPtwcs( fs, indf3, status );
/* Map the data array. */
ndfMap( indf3, "Data", "_INTEGER", "WRITE/BAD", (void **) &ipntr, &el,
status );
/* Create all-sky map using XPH projection. */
if( *status == SAI__OK ) {
/* Loop round every tile index. */
for( jtile = 0; jtile < skytiling.ntiles; jtile++ ) {
/* Get the zero-based (x,y) indices of the tile within an HPX projection.
This flips the bottom left half-facet up to the top right. */
smf_jsatilei2xy( jtile, &skytiling, &xt, &yt, NULL, status );
/* Convert these HPX indices to the corresponding indices within the
required projection. Note, the lower left facet is split by the above
call to smf_jsatilei2xy tile (i.e. (xt,yt) indices are *not* in the
"raw" mode). For instance, (0,0) is not a valid tile. */
smf_jsatilexyconv( &skytiling, proj, xt, yt, 0, &xt, &yt, status );
/* Get the vector index of the corresponding element of the all-sky NDF. */
if( proj == SMF__JSA_HPX || proj == SMF__JSA_HPX12 ) {
iv = xt + 5*skytiling.ntpf*yt;
} else {
iv = xt + 4*skytiling.ntpf*yt;
}
/* Report an error if this element has already been assigned a tile
index. Otherwise, store the tile index. */
if( ipntr[ iv ] == VAL__BADI ) {
ipntr[ iv ] = jtile;
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( "", "%s projection assigns multiple tiles to "
"pixel (%d,%d).", status, text, xt, yt );
break;
}
}
}
/* Store NDF title. */
sprintf( text, "JSA tile indices for %s data", skytiling.name );
ndfCput( text, indf3, "TITLE", status );
/* Store the instrument as a component in the SMURF extension. */
ndfXnew( indf3, "SMURF", "INSTRUMENT", 0, 0, &xloc, status );
ndfXpt0c( skytiling.name, indf3, "SMURF", "INSTRUMENT", status );
datAnnul( &xloc, status );
/* Close the NDF. */
ndfAnnul( &indf3, status );
}
/* Abort if an error has occurred. */
if( *status != SAI__OK ) goto L999;
/* Get the zero-based index of the required tile. If a null value is
supplied, annull the error and skip to the end. */
parGdr0i( "ITILE", 0, 0, skytiling.ntiles - 1, 0, &itile, status );
if( *status == PAR__NULL ) {
errAnnul( status );
goto L999;
}
/* See if the pixel origin is to be at the centre of the tile. */
parGet0l( "LOCAL", &local_origin, status );
/* Display the tile number. */
msgBlank( status );
msgSeti( "ITILE", itile );
msgSeti( "MAXTILE", skytiling.ntiles - 1);
msgOut( " ", " Tile ^ITILE (from 0 to ^MAXTILE):", status );
/* Get the FITS header, FrameSet and Region defining the tile, and the tile
bounds in pixel indices. */
smf_jsatile( itile, &skytiling, local_origin, proj, &fc, &fs, ®ion,
lbnd, ubnd, status );
/* Write the FITS headers out to a file, annulling the error if the
header is not required. */
if( *status == SAI__OK ) {
atlDumpFits( "HEADER", fc, status );
if( *status == PAR__NULL ) errAnnul( status );
}
/* If required, write the Region out to a text file. */
if( *status == SAI__OK ) {
atlCreat( "REGION", (AstObject *) region, status );
if( *status == PAR__NULL ) errAnnul( status );
}
/* Store the lower and upper pixel bounds of the tile. */
parPut1i( "LBND", 2, lbnd, status );
parPut1i( "UBND", 2, ubnd, status );
/* Display pixel bounds on the screen. */
msgSeti( "XL", lbnd[ 0 ] );
msgSeti( "XU", ubnd[ 0 ] );
msgSeti( "YL", lbnd[ 1 ] );
msgSeti( "YU", ubnd[ 1 ] );
msgOut( " ", " Pixel bounds: (^XL:^XU,^YL:^YU)", status );
/* Get the RA,Dec at the tile centre. */
if( astTest( fs, "SkyRef" ) ) {
ra0 = astGetD( fs, "SkyRef(1)" );
dec0 = astGetD( fs, "SkyRef(2)" );
/* Format the central RA and Dec. and display. Call astNorm on the
coordinates provided that the frame set has the correct number of
axes (which it should as it comes from smf_jsatile). */
norm_radec[0] = ra0;
norm_radec[1] = dec0;
if (astGetI(fs, "Naxes") == 2) astNorm(fs, norm_radec);
msgSetc( "RACEN", astFormat( fs, 1, norm_radec[ 0 ] ));
msgSetc( "DECCEN", astFormat( fs, 2, norm_radec[ 1 ] ));
msgOut( " ", " Centre (ICRS): RA=^RACEN DEC=^DECCEN", status );
/* Transform a collection of points on the edge of the region (corners and
side mid-points) from GRID coords to RA,Dec. */
point1[ 0 ] = 0.5;
point1[ 1 ] = 0.5;
point2[ 0 ] = ubnd[ 0 ] - lbnd[ 0 ] + 1;
point2[ 1 ] = ubnd[ 1 ] - lbnd[ 1 ] + 1;
gx[ 0 ] = point1[ 0 ]; /* Bottom left */
gy[ 0 ] = point1[ 1 ];
gx[ 1 ] = point1[ 0 ]; /* Centre left */
gy[ 1 ] = gy[ 0 ];
gx[ 2 ] = point1[ 0 ]; /* Top left */
gy[ 2 ] = point2[ 1 ];
gx[ 3 ] = gx[ 0 ]; /* Top centre */
gy[ 3 ] = point2[ 1 ];
gx[ 4 ] = point2[ 0 ]; /* Top right */
gy[ 4 ] = point2[ 1 ];
gx[ 5 ] = point2[ 0 ]; /* Centre right */
gy[ 5 ] = gy[ 0 ];
gx[ 6 ] = point2[ 0 ]; /* Bottom right */
gy[ 6 ] = point1[ 1 ];
gx[ 7 ] = gx[ 0 ]; /* Bottom centre */
gy[ 7 ] = point1[ 1 ];
astTran2( fs, 8, gx, gy, 1, ra, dec );
/* Find the arc-distance from the centre to the furthest point from the
centre. */
point1[ 0 ] = ra0;
point1[ 1 ] = dec0;
maxdist = -1.0;
for( i = 1; i < 8; i++ ) {
if( ra[ i ] != AST__BAD && dec[ i ] != AST__BAD ) {
point2[ 0 ] = ra[ i ];
point2[ 1 ] = dec[ i ];
dist = astDistance( fs, point1, point2 );
if( dist > maxdist ) maxdist = dist;
}
}
/* Convert from radius to diameter. */
maxdist *= 2.0;
/* Format this size as a dec value (i.e. arc-distance) and display it. */
if( maxdist > 0.0 ) {
msgSetc( "SIZE", astFormat( fs, 2, maxdist ) );
msgOut( " ", " Size: ^SIZE", status );
} else {
maxdist = AST__BAD;
msgOut( " ", " Size: <unknown>", status );
}
/* If a discontinuity passes through the tile, the centre and size may be
unknown. */
} else {
ra0 = AST__BAD;
dec0 = AST__BAD;
maxdist = AST__BAD;
msgOut( " ", " Centre (ICRS): RA=<unknown> DEC=<unknown>", status );
msgOut( " ", " Size: <unknown>", status );
}
/* Write the tile centre ra and dec in radians to the output parameters. */
parPut0d( "RACEN", norm_radec[ 0 ], status );
parPut0d( "DECCEN", norm_radec[ 1 ], status );
/* Write the size to the output parameter as radians. */
parPut0d( "SIZE", maxdist, status );
/* Get the translation of the environment variable JSA_TILE_DIR. */
jcmt_tiles = getenv( "JSA_TILE_DIR" );
/* Initialise the path to the tile's NDF to hold the root directory.
Use the current working directory if JSA_TILE_DIR is undefined. */
if( jcmt_tiles ) {
nc = 0;
tilendf = astAppendString( tilendf, &nc, jcmt_tiles );
} else {
nc = 512;
jcmt_tiles = astMalloc( nc );
while( !getcwd( jcmt_tiles, nc ) ) {
nc *= 2;
jcmt_tiles = astRealloc( jcmt_tiles, nc );
}
nc = 0;
tilendf = astAppendString( tilendf, &nc, jcmt_tiles );
jcmt_tiles = astFree( jcmt_tiles );
}
/* Complete the path to the tile's NDF. */
tilendf = astAppendString( tilendf, &nc, "/" );
tilendf = astAppendString( tilendf, &nc, skytiling.subdir );
dirlen = nc;
sprintf( text, "/tile_%d.sdf", itile );
tilendf = astAppendString( tilendf, &nc, text );
/* Write it to the output parameter. */
parPut0c( "TILENDF", tilendf, status );
/* See if the NDF exists, and store the flag in the output parameter. */
exists = access( tilendf, F_OK ) ? 0 : 1;
parPut0l( "EXISTS", exists, status );
/* If the NDF does not exist, create it if required. */
parGet0l( "CREATE", &create, status );
if( !exists && create && *status == SAI__OK ) {
/* Write the NDF info to the screen. */
msgSetc( "NDF", tilendf );
msgOutif( MSG__NORM, " ", " NDF: ^NDF (created)", status );
/* Temporarily terminate the NDF path at the end of the subdirectory. */
tilendf[ dirlen ] = 0;
/* Create the required directory (does nothing if the directory
already exists). It is given read/write/search permissions for owner
and group, and read/search permissions for others. */
(void) mkdir( tilendf, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH );
/* Replace the character temporarily overwritten above. */
tilendf[ dirlen ] = '/';
/* Now create the tile's NDF. */
ndfPlace( NULL, tilendf, &place, status );
ndfNew( skytiling.type, 2, lbnd, ubnd, &place, &indf1, status );
/* Fill its data array with zeros. */
ndfMap( indf1, "Data", skytiling.type, "WRITE/ZERO", &pntr, &el,
status );
/* Store the WCS FrameSet. */
ndfPtwcs( fs, indf1, status );
/* If the instrument jsatiles.have variance, fill the variance array with zeros. */
if( skytiling.var ) {
ndfMap( indf1, "Variance", skytiling.type, "WRITE/ZERO", &pntr,
&el, status );
}
/* Create a SMURF extension. */
ndfXnew( indf1, SMURF__EXTNAME, SMURF__EXTTYPE, 0, NULL, &xloc, status );
/* Store the tile number and instrument name in the extension. */
datNew0I( xloc, "TILE", status );
datFind( xloc, "TILE", &cloc, status );
datPut0I( cloc, itile, status );
datAnnul( &cloc, status );
datNew0C( xloc, "INSTRUMENT", strlen( skytiling.name ), status );
datFind( xloc, "INSTRUMENT", &cloc, status );
datPut0C( cloc, skytiling.name, status );
datAnnul( &cloc, status );
/* Create a weights NDF within the SMURF extension, and fill its data
array with zeros. */
ndfPlace( xloc, "WEIGHTS", &place, status );
ndfNew( skytiling.type, 2, lbnd, ubnd, &place, &indf2, status );
ndfMap( indf2, "Data", skytiling.type, "WRITE/ZERO", &pntr, &el,
status );
ndfPtwcs( fs, indf2, status );
ndfAnnul( &indf2, status );
/* Annul the extension locator and the main NDF identifier. */
datAnnul( &xloc, status );
ndfAnnul( &indf1, status );
/* Write the NDF info to the screen. */
} else {
msgSetc( "NDF", tilendf );
msgSetc( "E", exists ? "exists" : "does not exist" );
msgOut( " ", " NDF: ^NDF (^E)", status );
}
/* Initialise TBND and TLBND to indicate no overlap. */
tlbnd[ 0 ] = 1;
tlbnd[ 1 ] = 1;
tubnd[ 0 ] = 0;
tubnd[ 1 ] = 0;
/* Attempt to to get an AST Region (assumed to be in some 2D sky coordinate
system) using parameter "TARGET". */
if( *status == SAI__OK ) {
kpg1Gtobj( "TARGET", "Region",
(void (*)( void )) F77_EXTERNAL_NAME(ast_isaregion),
&obj, status );
/* Annul the error if none was obtained. */
if( *status == PAR__NULL ) {
errAnnul( status );
/* Otherwise, use the supplied object. */
} else {
target = (AstRegion *) obj;
/* If the target Region is 3-dimensional, remove the third axis, which
is assumed to be a spectral axis. */
if( astGetI( target, "Naxes" ) == 3 ) {
axes[ 0 ] = 1;
axes[ 1 ] = 2;
target = astPickAxes( target, 2, axes, NULL );
}
/* See if there is any overlap between the target and the tile. */
overlap = NULL;
flag = astOverlap( region, target );
if( flag == 0 ) {
msgOut( "", " Cannot convert between the coordinate system of the "
"supplied target and the tile.", status );
} else if( flag == 1 || flag == 6 ) {
msgOut( "", " There is no overlap between the target and the tile.",
status );
} else if( flag == 2 ) {
msgOut( "", " The tile is contained within the target.",
status );
tlbnd[ 0 ] = lbnd[ 0 ];
tlbnd[ 1 ] = lbnd[ 1 ];
tubnd[ 0 ] = ubnd[ 0 ];
tubnd[ 1 ] = ubnd[ 1 ];
} else if( flag == 3 ) {
overlap = astCmpRegion( region, target, AST__AND, " " );
} else if( flag == 4 ) {
overlap = astCmpRegion( region, target, AST__AND, " " );
} else if( flag == 5 ) {
msgOut( "", " The target and tile are identical.",
status );
tlbnd[ 0 ] = lbnd[ 0 ];
tlbnd[ 1 ] = lbnd[ 1 ];
tubnd[ 0 ] = ubnd[ 0 ];
tubnd[ 1 ] = ubnd[ 1 ];
} else if( *status == SAI__OK ) {
*status = SAI__OK;
errRepf( "", "Unexpected value %d returned by astOverlap "
"(programming error).", status, flag );
}
/* If a region containing the intersection of the tile and target was
created above, map it into the grid coordinate system of the tile. */
if( overlap ) {
overlap = astMapRegion( overlap, astGetMapping( fs, AST__CURRENT,
AST__BASE ),
astGetFrame( fs, AST__BASE ) );
/* Get its GRID bounds. */
astGetRegionBounds( overlap, dlbnd, dubnd );
/* Convert to integer. */
tlbnd[ 0 ] = ceil( dlbnd[ 0 ] - 0.5 );
tlbnd[ 1 ] = ceil( dlbnd[ 1 ] - 0.5 );
tubnd[ 0 ] = ceil( dubnd[ 0 ] - 0.5 );
tubnd[ 1 ] = ceil( dubnd[ 1 ] - 0.5 );
/* Convert to PIXEL indices within the tile. */
tlbnd[ 0 ] += lbnd[ 0 ] - 1;
tlbnd[ 1 ] += lbnd[ 1 ] - 1;
tubnd[ 0 ] += lbnd[ 0 ] - 1;
tubnd[ 1 ] += lbnd[ 1 ] - 1;
msgOutf( "", " The target overlaps section (%d:%d,%d:%d).",
status, tlbnd[ 0 ], tubnd[ 0 ], tlbnd[ 1 ], tubnd[ 1 ] );
}
}
}
/* Store the pixel index bounds of the tiles overlap with the target. */
parPut1i( "TLBND", 2, tlbnd, status );
parPut1i( "TUBND", 2, tubnd, status );
/* Arrive here if an error occurs. */
L999:;
/* Free resources. */
tilendf = astFree( tilendf );
/* End the AST context. */
astEnd;
/* Issue a status indication.*/
msgBlank( status );
if( *status == SAI__OK ) {
msgOutif( MSG__VERB, "", "JSATILEINFO succeeded.", status);
} else {
msgOutif( MSG__VERB, "", "JSATILEINFO failed.", status);
}
}
F77_SUBROUTINE(configecho)( INTEGER(STATUS) ){
/*
*+
* Name:
* CONFIGECHO
* Purpose:
* Displays one or more configuration parameters.
* Language:
* C (designed to be called from Fortran)
* Type of Module:
* ADAM A-task
* Invocation:
* CALL CONFIGECHO( STATUS )
* Arguments:
* STATUS = INTEGER (Given and Returned)
* The global status.
* Description:
* This application displays the name and value of one or all
* configuration parameters, specified using Parameters CONFIG or
* NDF. If a single parameter is displayed, its value is also
* written to an output parameter. If the parameter value is not
* specified by the CONFIG, NDF or DEFAULTS parameter, then the
* value supplied for DEFVAL is displayed.
*
* If an input NDF is supplied then configuration parameters
* are read from its history (see Parameters NDF and APPLICATION).
*
* If values are supplied for both CONFIG and NDF, then the
* differences between the two sets of configuration parameters
* are displayed (see Parameter NDF).
* Usage:
* configecho name config [defaults] [select] [defval]
* ADAM Parameters:
* APPLICATION = LITERAL (Read)
* When reading configuration parameters from the history
* of an NDF, this parameter specifies the name of the application
* to find in the history. There must be a history component
* corresponding to the value of this parameter, and it must
* include a CONFIG group. [current value]
* CONFIG = GROUP (Read)
* Specifies values for the configuration parameters. If the string
* "def" (case-insensitive) or a null (!) value is supplied, the
* configuration parameters are obtained using Parameter NDF. If
* a null value is also supplied for NDF, a set of default
* configuration parameter values will be used, as specified by
* Parameter DEFAULTS.
*
* The supplied value should be either a comma-separated list of
* strings or the name of a text file preceded by an up-arrow
* character "^", containing one or more comma-separated lists of
* strings. Each string is either a "keyword=value" setting, or the
* name of a text file preceded by an up-arrow character "^". Such
* text files should contain further comma-separated lists which
* will be read and interpreted in the same manner (any blank lines
* or lines beginning with "#" are ignored). Within a text file,
* newlines can be used as delimiters, as well as commas. Settings
* are applied in the order in which they occur within the list,
* with later settings overriding any earlier settings given for
* the same keyword.
*
* Each individual setting should be of the form "<keyword>=<value>".
* If a non-null value is supplied for Parameter DEFAULTS, an error
* will be reported if CONFIG includes values for any parameters
* that are not included in DEFAULTS.
* DEFAULTS = LITERAL (Read)
* The path to a file containing the default value for every
* allowed configuration parameter. If null (!) is supplied, no
* defaults will be supplied for parameters that are not specified
* by CONFIG, and no tests will be performed on the validity of
* paramter names supplied by CONFIG. [!]
* DEFVAL = LITERAL (Read)
* The value to return if no value can be obtained for the named
* parameter, or if the value is "<undef>". [<***>]
* NAME = LITERAL (Read)
* The name of the configuration parameter to display. If set to
* null (!), then all parameters defined in the configuration are
* displayed.
* NDF = NDF (Read)
* An NDF file containing history entries which include
* configuration parameters. If not null (!) the history
* of the NDF will be searched for a component corresponding
* to the Parameter APPLICATION. The Parameter CONFIG
* is then optional, but if it too is not null (!) then
* the output will show the differences between the configuration
* stored in the NDF history and the given configuration:
* new parameters and those different from the reference
* configuration (given by Parameter CONFIG) are prefixed
* with "+" and those which are the same as the reference
* configuration are prefixed with "-". [!]
* SELECT = GROUP (Read)
* A group that specifies any alternative prefixes that can be
* included at the start of any parameter name. For instance, if
* this group contains the two entries "450=1" and "850=0", then
* either CONFIG or DEFAULTS can specify two values for any single
* parameter -- one for the parameter prefixed by "450." and another
* for the parameter prefixed by "850.". Thus, for instance, if
* DEFAULTS defines a parameter called "filter", it could include
* "450.filter=300" and "850.filter=600". The CONFIG parameter could
* then either set the filter parameter for a specific prefix (as
* in "450.filter=234"); or it could leave the prefix unspecified,
* in which case the prefix used is the first one with a
* non-zero value in SELECT (450 in the case of this example - 850
* has a value zero in SELECT). Thus the names of the items in
* SELECT define the set of allowed alternative prefixes, and the
* values indicate which one of these alternatives is to be used
* (the first one with non-zero value). [!]
* SORT = _LOGICAL (Read)
* If TRUE then sort the listed parameters in to alphabetical order.
* Otherwise, retain the order they have in the supplied
* configuration. Only used if a null (!) value is supplied for
* Parameter NAME. [FALSE]
* VALUE = LITERAL (Write)
* The value of the configuration parameter, or "<***>" if the
* parameter has no value in CONFIG and DEFAULTS.
* Examples:
* configecho m81 ^myconf
* Report the value of configuration parameter "m81" defined within
* the file "myconf". If the file does not contain a value for
* "m81", then "<***>" is displayed.
* configecho type ^myconf select="m57=0,m31=1,m103=0"
* Report the value of configuration parameter "type" defined within
* the file "myconf". If the file does not contain a value for
* "type", then the value of "m31.type" will be reported instead. If
* neither is present, then "<***>" is displayed.
* configecho flt.filt_edge_largescale \
* config=^/star/share/smurf/dimmconfig.lis \
* defaults=/star/bin/smurf/smurf_makemap.def \
* select="450=1,850=0"
* Report the value of configuration parameter "flt.filt_edge_largescale"
* defined within the file "/star/share/smurf/dimmconfig.lis", using
* defaults from the file "/star/bin/smurf/smurf_makemap.def". If
* dimmconfig.lis does not contain a value for "flt.filt_edge_largescale"
* then it is searched for "450.flt.filt_edge_largescale" instead. An
* error is reported if dimmconfig.lis contains values for any
* items that are not defined in smurf_makemap.def.
* configecho ndf=omc1 config=^/star/share/smurf/dimmconfig.lis \
* defaults=/star/bin/smurf/smurf_makemap.def \
* application=makemap name=! sort select="450=0,850=1"
* Show how the configuration used to generate the 850um map
* of OMC1 differs from the basic dimmconfig.lis file.
* Copyright:
* Copyright (C) 2012-3 Science & Technology Facilities Council.
* All Rights Reserved.
* Licence:
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either Version 2 of
* the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be
* useful, but WITHOUT ANY WARRANTY; without even the implied
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
* Authors:
* DSB: David S. Berry
* GSB: Graham S. Bell
* {enter_new_authors_here}
* History:
* 10-DEC-2012 (DSB):
* Original version.
* 6-FEB-2013 (DSB):
* Added parameter DEFVAL.
* 11-FEB-2013 (DSB):
* Added parameter SORT and allow all parameters to be listed by
* providing a null value for NAME.
* 11-FEB-2013 (GSB):
* Added ability to read configuration from history entries.
* 13-FEB-2013 (DSB):
* Nullify AST object pointers when the objects are annulled,
* to avoid re-use of dead pointers.
* 14-FEB-2013 (DSB):
* Allow the SELECT feature to be used even if no DEFAULTS file is
* supplied (see the new entry in the "Examples:" section).
* 15-FEB-2013 (DSB):
* Expand the prologue docs, and use NULL in place of zero for pointers.
* 22-FEB-2013 (DSB):
* Guard against seg fault in HistoryKeymap when the NDF does
* not contain the required CONFIG entry in the History
* component.
* {enter_further_changes_here}
*-
*/
GENPTR_INTEGER(STATUS)
/* Local Variables: */
AstKeyMap *keymap2;
AstKeyMap *keymap;
Grp *grp = NULL;
char *dot;
char *pname;
char defs[250];
char defval[250];
char name[250];
const char *value;
const char *historyValue = NULL;
int showall;
int sort;
size_t size;
int indf = 0;
int nrec;
int i;
char application[NDF__SZAPP];
char applicationi[NDF__SZAPP];
/* Abort if an error has already occurred. */
if( *STATUS != SAI__OK ) return;
/* Begin an AST context */
astBegin;
/* Get the value to return if no value can be obtained for the named
parameter, of it it has a value of <undef>. */
parGet0c( "DEFVAL", defval, sizeof(defval), STATUS );
/* Get any defaults file, annuling the error if null (!) is supplied. */
if( *STATUS == SAI__OK ) {
parGet0c( "DEFAULTS", defs, sizeof(defs), STATUS );
if( *STATUS == PAR__NULL ) {
errAnnul( STATUS );
defs[0] = 0;
}
}
/* Get the NDF identifier if requested. */
ndfBegin();
if (*STATUS == SAI__OK) {
ndfAssoc("NDF", "READ", &indf, STATUS);
if (*STATUS == PAR__NULL) {
errAnnul(STATUS);
indf = 0;
}
else {
parGet0c("APPLICATION", application, sizeof(application), STATUS);
/* Check now for error because the block below allowing an undefined
* CONFIG clears this status otherwise. */
if (*STATUS != SAI__OK) goto L999;
}
}
/* See if any alternate keyword prefixes are allowed, and if so determine
which of the alternatices is to be displayed. */
kpg1Gtgrp( "SELECT", &grp, &size, STATUS );
if( *STATUS == PAR__NULL ) {
grpDelet( &grp, STATUS );
errAnnul( STATUS );
keymap2 = NULL;
} else {
kpg1Kymap( grp, &keymap2, STATUS );
grpDelet( &grp, STATUS );
}
/* Create a KeyMap holding the selected alternative for each keyword, and
also supply defaults for any missing values (if a defaults file was
supplied by the user). */
keymap = kpg1Config( "CONFIG", defs[0]?defs:NULL, keymap2, 0, STATUS );
/* Allow it to be NULL if we're reading an NDF because we'll replace
keymap with historyConfig later if necessary. */
if( indf && *STATUS == PAR__NULL ) {
errAnnul(STATUS);
keymap = NULL;
}
/* Abort if an error has occurred. */
if( *STATUS != SAI__OK ) goto L999;
/* Get the name of the required parameter, and convert to upper case (if
supplied). If not supplied, set a flag indicating that all parameters
should be displayed. */
parGet0c( "NAME", name, sizeof(name), STATUS );
if( *STATUS == PAR__NULL ) {
errAnnul( STATUS );
showall = 1;
} else {
showall = 0;
astChrCase( NULL, name, 1, 0 );
}
/* Attempt to find the NDF's corresponding history record. */
if (indf && *STATUS == SAI__OK) {
ndfHnrec(indf, &nrec, STATUS);
for (i = 0; i < nrec; i ++) {
ndfHinfo(indf, "APPLICATION", i + 1, applicationi,
sizeof(applicationi), STATUS);
if (! strncasecmp(application, applicationi, strlen(application))) {
ndfHout(indf, i + 1, HistoryKeyMap, STATUS);
break;
}
}
if (*STATUS == SAI__OK && ! historyConfig) {
*STATUS = SAI__ERROR;
errRepf("CONFIGECHO_ERR", "CONFIGECHO: Failed to find %s "
"configuration in NDF history.", STATUS, application);
}
else if (! keymap) {
keymap = historyConfig;
historyConfig = NULL;
}
}
if( *STATUS == SAI__OK ) {
/* First deal with cases where we are displaying a single parameter
value. */
if( !showall ) {
/* Loop round each section of the name that ends with a dot. */
value = defval;
pname = name;
dot = strchr( pname, '.' );
while( dot && keymap ) {
/* Get a nested keymap with the name that occurs prior to the dot. If
found, use it in place of the parent keymap. */
pname[ dot - pname ] = 0;
if( astMapGet0A( keymap, pname, &keymap2 ) ) {
astAnnul( keymap );
keymap = keymap2;
} else {
keymap = astAnnul( keymap );
}
/* If historyConfig exists, do the same there. */
if (historyConfig) {
if (astMapGet0A(historyConfig, pname, &keymap2)) {
astAnnul(historyConfig);
historyConfig = keymap2;
}
else {
historyConfig = astAnnul(historyConfig);
}
}
/* Re-instate the original dot, and move on to find the next dot. */
pname[ dot - pname ] = '.';
pname = dot + 1;
dot = strchr( pname, '.' );
}
/* Ensure no error is reported if the parameter is not found in the
KeyMap. */
if( keymap ) {
astClear( keymap, "KeyError" );
/* Get the parameter value as a string. */
astMapGet0C( keymap, pname, &value );
}
if (historyConfig) {
astClear(historyConfig, "KeyError");
astMapGet0C(historyConfig, pname, &historyValue);
/* In NDF history mode we only want to return a value if it
was found in the configuration from the history. */
if (historyValue) {
if (strcmp(value, historyValue)) {
msgOutf("", "+ %s", STATUS, historyValue);
}
else {
msgOutf("", "- %s", STATUS, historyValue);
}
parPut0c("VALUE", historyValue, STATUS);
}
}
else {
/* Display it. */
msgOut( "", value, STATUS );
/* Write it to the output parameter. */
parPut0c( "VALUE", value, STATUS );
}
/* Now deal with cases were we are displaying all parameter values. */
} else {
/* See if the values should be sorted. */
parGet0l( "SORT", &sort, STATUS );
/* Display them. */
if (historyConfig) {
DisplayKeyMap( historyConfig , sort, "", keymap, STATUS );
}
else {
DisplayKeyMap( keymap, sort, "", NULL, STATUS );
}
}
}
/* Tidy up. */
L999:;
/* End the AST context */
astEnd;
/* Close the NDF if open. */
ndfEnd(STATUS);
/* If an error has occurred, issue another error report identifying the
program which has failed (i.e. this one). */
if( *STATUS != SAI__OK ) {
errRep( "CONFIGECHO_ERR", "CONFIGECHO: Failed to echo configuration "
"parameters.", STATUS );
}
}