/**
 *  VODATA -- Query VO Data services (Cone, SIAP, etc)
 *
 *  Usage:  vodata [-<flags>] [<service>] [object|file|position]
 *
 *  Where
 *       -%%,--test             run unit tests
 *       -h,--nelp              this message
 *       -d,--debug             enable debug messages
 *       -r,--return            return result from method
 *
 *
 *
 *
 *  @file       vodata.c
 *  @author     Mike Fitzpatrick
 *  @date       7/13/07
 *
 *  @brief      Query VO Data services (Cone, SIAP, etc)
 */

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <ctype.h>
#include <getopt.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/time.h>
#include <time.h>
#include "VOClient.h"
#include "voAppsP.h"
#include "samp.h"




#define VOD_DEBUG  (getenv("VOD_DBG")||access("/tmp/VOD_DBG",F_OK)==0)


/*  Task structure.
 */
typedef struct {
   char  *name;                         /* task name                    */
   int  (*func)(int argc, char **argv, size_t *len, void **result);

   int   ntests;                        /* number of unit tests         */
   int   npass;                         /* number of passed tests       */
   int   nfail;                         /* number of failed tests       */
} Task;



/* Local processing definitions.
*/
svcParams pars[MAX_THREADS];		/* parameter array		*/

int	format	    = F_CSV;		/* output format		*/
int	apos	    = 0;		/* argv position		*/
int	sv_apos	    = -1;		/* saved argv position		*/
int     nservices   = 0;		/* num. of cone services	*/
int     nobjects    = 0;		/* num. objects to query	*/
int     filenum     = 0;		/* download file number		*/
int     rd_stdin    = 0;		/* reading from stdin?		*/
int     wr_stdout   = 0;		/* writing to stdout?		*/
int     do_votable  = 0;                /* output a Resource VOTable    */
int     svcNumber   = -1;               /* service number to call	*/
int     dalOnly     = 1;                /* only query DAL services?     */
int     simple_out  = 0;                /* use simple output name?	*/

int	inventory   = FALSE;		/* do inventory?		*/
int	quiet	    = FALSE;		/* no output at all?		*/
int	verbose     = TRUE;		/* DAL verbose level		*/
int     all_data    = FALSE;		/* get all the data?		*/
int     file_get    = FALSE;		/* file number to get		*/
#ifdef REG10_KLUDGE
int     reg10       = FALSE;		/* use Registry 1.0 scheme?     */
#endif
int     raw_vizier  = FALSE;		/* use Registry 1.0 scheme?     */
int     count	    = TRUE;		/* return count of results	*/
int     meta	    = FALSE;		/* metadata return?		*/
int     extract	    = EX_NONE;		/* extract pos/acrefs?		*/
int     count_only  = FALSE;		/* print only matched records?  */
int     save_res    = TRUE;		/* save results?		*/
int     all_named   = FALSE;		/* all objects named?		*/
int     use_name    = FALSE;		/* use object name in output?	*/
int     url_proc    = FALSE;		/* processing URLs only?	*/
int     force_svc   = FALSE;		/* assume URLs are ServiceURLs?	*/
int     svc_list    = FALSE;		/* list services queried        */
int     obj_list    = FALSE;		/* list objects queried         */
int     fixed_svc   = FALSE;		/* service is fixed on cmdline  */
int     fixed_obj   = FALSE;		/* object is fixed on cmdline   */
int     fixed_pos   = FALSE;		/* position is fixed on cmdline */
int     data_type   = DT_ANY;		/* data type			*/
int     proxy       = FALSE;		/* use proxy server		*/
int     res_all     = FALSE;		/* print all results?		*/
int     force_read  = FALSE;		/* force reading of input table	*/
int     longlines   = FALSE;		/* output long lines?		*/
int     iportal     = FALSE;		/* iportal support?		*/
int     numout      = FALSE;		/* numeric output sorting?	*/
int     samp        = FALSE;		/* broadcast table via SAMP	*/

int	max_download= DEF_DOWNLOADS;	/* max download procs to run	*/
int	max_procs   = DEF_NPROCS;	/* max children to run		*/
int	max_threads = DEF_NTHREADS;	/* max threads to run		*/

int     table_hskip = 0;		/* no. of table eeader to skip	*/
int     table_nlines= 0;		/* max lines of table to read	*/
int     table_sample= 1;		/* table sample			*/

int     group           = 0;		/* resolve identifiers in groups*/
int     nterms          = 0;		/* No. of terms			*/
char   *terms[128];			/* search terms			*/

char	*typestr    = (char *) NULL;	/* service type string		*/
char	*bpass      = (char *) NULL;	/* bandpass type string		*/
char	*output     = (char *) NULL;	/* root output filename		*/
char    *delim	    = " \t,|;";		/* input table delimiter	*/
char    *cols	    = "1,2";		/* input table columns		*/
char    *ecols	    = (char *) NULL;	/* input table exact columns	*/
char    *sources    = (char *) NULL;    /* source file			*/
char    *resources  = (char *) NULL;    /* resource file		*/
char    *sampName   = (char *) NULL;    /* SAMP appName 		*/

char	*d2_band    = (char *) NULL;	/* DAL2 BAND parameter		*/
char	*d2_time    = (char *) NULL;	/* DAL2 TIME parameter		*/
char	*d2_format  = (char *) NULL;	/* DAL2 FORMAT parameter	*/
char	*d2_version = (char *) NULL;	/* DAL2 VERSION parameter	*/

char	*tmpdir	    = "/tmp/";		/* temp directory		*/
char 	wrkdir[SZ_FNAME];		/* working directory		*/

double	sr	    = DEF_SR;		/* default search radius	*/

int	dverbose    = 0;		/* verbose debug output?	*/
int	debug	    = 0;		/* debug output?		*/
int     samp_p      = 0;		/* SAMP interface handler	*/

static  int status  = OK;		/* return status		*/


time_t	rs_time	    = (time_t) 0, 
	re_time	    = (time_t) 0;	/* reg/obj resolution times	*/
time_t	qs_time	    = (time_t) 0, 
	qe_time	    = (time_t) 0;	/* data query times		*/
time_t	as_time	    = (time_t) 0, 
	ae_time	    = (time_t) 0;	/* data access times		*/

Service  *svcList, *svcTail;		/* Service linked list		*/
Object   *objList, *objTail;		/* Obj/Posn linked list		*/
Acref    *acList, *acTail;		/* Acref linked list		*/
int      nacrefs    = 0;		/* no. of acrefs		*/

FILE	*arg_fd	    = (FILE *) NULL;	/* argument-file descriptor	*/


/* KML Options.
*/
int     kml_max         = 50,           /* max placemarks to write      */
        kml_sample      = 0,            /* output sample step           */
        kml_region      = TRUE,         /* draw bounding region poly    */
        kml_verbose     = TRUE,         /* verbose labels		*/
        kml_label       = TRUE,         /* draw placemark labels        */
        kml_byObj       = TRUE,         /* group by object/position	*/
        kml_bySvc       = FALSE,        /* group by service name	*/
        kml_byBoth      = FALSE;        /* group by both		*/

/* HTML Options.
*/
int     html_header     = TRUE,         /* print a HTML header on page	*/
        html_border     = TRUE,         /* put a border on the table?	*/
        html_color      = TRUE;         /* colorize the table		*/


extern int   errno;			/* system error code		*/

extern int   ra_col,  ra_span,		/* table input			*/
	     dec_col, dec_span,
	     id_col,  id_span;
extern int   svcIndex, objIndex;

extern int   isDecimal (char *s);
extern int   isSexagesimal (char *s);

extern int   vot_parseObjectList (char *list, int isCmdLine);
extern int   vot_countObjectList (void);
extern int   vot_parseServiceList (char *list, int dalOnly);
extern int   vot_countServiceList (void);
extern int   vot_decodeRanges (char *range_string, int *ranges, int max_ranges,
		int *nvalues);
extern int   is_in_range (int ranges[], int number);
extern int   vot_atoi (char *v);

extern void  vot_addToAclist (char *url, char *fname);
extern void  vot_procAclist (void);
extern void  vot_freeAclist (void);
extern void  vot_freeServiceList (void);
extern void  vot_resetServiceCounters (void);
extern void  vot_freeObjectList (void);
extern void  vot_printCountHdr (void);
extern void  vot_readObjFile (char *fname);
extern void  vot_readSvcFile (char *fname, int dalOnly);

extern double vot_atof (char *v);

/*  Tasking execution procedure.
 */
extern int  vo_runTask (char *method, Task *apps, int argc, char **argv, 
		size_t *len, void **result);
extern int  vo_taskTest (Task *self, char *arg, ...);
extern void vo_taskTestFile (char *str, char *fname);
extern void vo_taskTestReport (Task self);

extern int  vo_setResultFromFile (char *fname, size_t *len, void **data);
extern int  vo_setResultFromString (char *str, size_t *len, void **data);
extern int  vo_setResultFromInt (int value, size_t *len, void **data);
extern int  vo_setResultFromReal (float value, size_t *len, void **data);
extern int  vo_appendResultFromString (char *str, size_t *len, void **data,
                size_t *maxlen);


#ifdef VO_INVENTORY
extern char *vot_doInventory (void);
#endif
extern char *vot_urlFname (char *url);
extern char *vot_getOFName (svcParams *pars, char *extn, int pid);
extern char *vot_getOFIndex (svcParams *pars, char *extn, int pid);
extern char *vot_normalize (char *str);
extern char *vot_svcTypeCode (int type);

static int   vot_parseArgToken (char *arg, char *next, int pos, int *inc);
static int   vot_validateOptions (void);
static int   vot_getNextCmdline (void);
static void  vot_runSvcThreads (void);
static void  vot_printProcStat (Proc *procList, char *svc_name, int fail_only);
static void  vot_setProcStat (Service *svc, int pid, int status);

static void  vot_printProcTime ();
static char *vot_requiredArg (char *arg);
static char *vot_optionalArg (char *arg);
static char  vot_setArgWord (char *arg, char *val);
static char *vot_stat2code (int status);
static char *vizPatch (char *url);
/*
static char *vot_cnvType (char *intype);
*/

static void  vot_printUsage (void);
static void  vot_printExamples (void);

void   *vot_procObjs (void *arg);
void    vot_printSvcList (Service *sl);
void    vot_printSvcHdr (void);

    
pthread_mutex_t svc_mutex = PTHREAD_MUTEX_INITIALIZER;


/*  Task specific option declarations.
 */
int  vodata (int argc, char **argv, size_t *len, void **result);

static int mf = 0;
static Task  self  	= {  "vodata",  vodata,  0,  0,  0  };

/*  Note:  the leading ':' in the opts string is required to suppress errors
 */
static char *opts  	= ":%hrNSACFHIKMO:RTVXab:ce:fgi:mno:p:qr:s:t:uv";

static struct option long_opts[] = {
    { "test",        2, 0, '%' },	/* test (std)			*/
    { "help",        2, 0, 'h' },	/* help (std)			*/
    { "return",      2, 0, 'r' },	/* return (std)			*/

    { "numeric",     2, 0, 'N' },	/* numeric output name		*/
    { "simple",      2, 0, 'S' },	/* simple output name		*/

    { "ascii",       2, 0, 'A' },	/* ASCII output			*/
    { "csv",         2, 0, 'C' },	/* CSV output			*/
    { "fits",        2, 0, 'F' },	/* FITS table output		*/
    { "html",        2, 0, 'H' },	/* HTML output			*/
    { "inventory",   2, 0, 'I' },	/* inventory (not used)		*/
    { "kml",         2, 0, 'K' },	/* KML output			*/
    { "verbmeta",    2, 0, 'M' },	/* verbose metadata		*/
    { "output",      2, 0, 'O' },	/* root output name		*/
    { "raw",         2, 0, 'R' },	/* Raw output			*/
    { "tsv",         2, 0, 'T' },	/* TSV output			*/
    { "votable",     2, 0, 'V' },	/* VOTable output		*/
    { "xml",         2, 0, 'X' },	/* XML output			*/

    { "all",         0, 0, 'a' },	/* all data			*/
    { "bandpass",    1, 0, 'b' },	/* bandpass			*/
    { "count",       2, 0, 'c' },	/* count results		*/
    { "debug",       2, 0, 'd' },	/* debug			*/
    { "extract",     1, 0, 'e' },	/* extract			*/
    { "force",       2, 0, 'f' },	/* force table read		*/
    { "get",         2, 0, 'g' },	/* get specific results		*/
    { "input",       1, 0, 'i' },	/* get args from input file	*/
    { "meta",        2, 0, 'm' },	/* metadata			*/
    { "nosave",      2, 0, 'n' },	/* no-save results		*/
    { "object",      1, 0, 'o' },	/* query object name		*/
    { "pos",         1, 0, 'p' },	/* query position		*/
    { "quiet",       2, 0, 'q' },	/* suppress output		*/
    { "sr",          1, 0, 'r' },	/* search radius		*/
    { "svc",         1, 0, 's' },	/* data service			*/
    { "type",        1, 0, 't' },	/* type string			*/
    { "url",         2, 0, 'u' },	/* url download			*/
    { "verbose",     2, 0, 'v' },	/* verbose			*/
 
    { "bandpass",    1, &mf,  1 },	/* req'd arg word		*/
    { "cols",        1, &mf,  2 },	/* req'd arg word		*/
    { "ecols",       1, &mf,  3 },	/* req'd arg word		*/
    { "delim",       1, &mf,  4 },	/* req'd arg word		*/
    { "kml",         1, &mf,  5 },	/* req'd arg word		*/
    { "max",         1, &mf,  6 },	/* req'd arg word		*/
    { "nlines",      1, &mf,  7 },	/* req'd arg word		*/
    { "object",      1, &mf,  8 },	/* req'd arg word		*/
    { "output",      1, &mf,  9 },	/* req'd arg word		*/
    { "pos",         1, &mf, 10 },	/* req'd arg word		*/
    { "sample",      1, &mf, 11 },	/* req'd arg word		*/
    { "svc",         1, &mf, 12 },	/* req'd arg word		*/
    { "type",        1, &mf, 13 },	/* req'd arg word		*/
    { "web",         1, &mf, 15 },	/* req'd arg word		*/
    { "band",        1, &mf, 16 },	/* req'd arg word		*/
    { "time",        1, &mf, 17 },	/* req'd arg word		*/
    { "format",      1, &mf, 18 },	/* req'd arg word		*/
    { "version",     1, &mf, 19 },	/* req'd arg word		*/

    { "onefile",     2, &mf, 20 },	/* one-file output		*/
    { "extract",     2, &mf, 21 },	/* opt arg word			*/
    { "ep",          2, &mf, 22 },	/* opt arg word			*/
    { "eu",          2, &mf, 23 },	/* opt arg word			*/
    { "eh",          2, &mf, 24 },	/* opt arg word			*/
    { "ek",          2, &mf, 25 },	/* opt arg word			*/
    { "eK",          2, &mf, 26 },	/* opt arg word			*/
    { "hskip",       2, &mf, 27 },	/* opt arg word			*/

    { "wh",          2, &mf, 30 },	/* opt arg word			*/
    { "wb",          2, &mf, 31 },	/* opt arg word			*/
    { "wc",          2, &mf, 32 },	/* opt arg word			*/

    { "webborder",   2, &mf, 40 },	/* no arg word			*/
    { "webheader",   2, &mf, 41 },	/* no arg word			*/
    { "webcolor",    2, &mf, 42 },	/* no arg word			*/
    { "webnoborder", 2, &mf, 43 },	/* no arg word			*/
    { "webnoheader", 2, &mf, 44 },	/* no arg word			*/
    { "webnocolor",  2, &mf, 45 },	/* no arg word			*/
    { "vverbose",    0, &mf, 46 },	/* no arg word			*/

    { "debug",       0, &mf, 99 },	/* no arg word			*/

    { NULL,       0, 0,  0 }
};

extern char **vo_paramInit (int argc, char *argv[], 
		char *opts, struct option long_opts[]);
extern int    vo_paramNext (char *opts, struct option long_opts[], 
                int argc, char *argv[], char *optval, int *posindex);
extern void   vo_paramFree (int argc, char *argv[]);


static void Usage (void);
static void Tests (char *input);





/************************************************************************
**  Program main()
*/
int
vodata (int argc, char *argv[], size_t *reslen, void **result)
{
    int    i, ch, pos=0;
    char  *eval, *argfile, *next_arg, posn[SZ_LINE];
    char  **pargv, optval[SZ_FNAME];


    /*  Initialize the VOClient code.  Error messages are printed by the
    **  interface so we just quit if there is a problem.
    */
    if (voc_initVOClient ("runid=voc.vodata") == ERR)  {
	fprintf (stderr, "Error: cannot connect to VOClient daemon\n");
        return (ERR);
    }

			
    /* Initialize the global structs.
    */
    memset (&colRange, 0, sizeof (Range));
    memset (&rowRange, 0, sizeof (Range));
    memset (&fileRange, 0, sizeof (Range));
    colRange.nvalues  = RANGE_ALL;
    rowRange.nvalues  = RANGE_ALL;
    fileRange.nvalues = RANGE_NONE;


    /* Get some environment definitions.  We allow the command-line flags
    ** to override these values.
    */
    if ((eval = getenv("VOC_MAX_DOWNLOADS")))
	max_download = vot_atoi (eval);
    if ((eval = getenv("VOC_MAX_PROCS")))
	max_procs = vot_atoi (eval);
    if ((eval = getenv("VOC_MAX_THREADS")))
	max_threads = vot_atoi (eval);


    /*  Initializations.
     */
    *reslen   = 0;
    *result   = NULL;
    apos      = 0;
    svcIndex  = 0;
    objIndex  = 0;
    all_data  = 0;


    rs_time = time ((time_t) NULL);

    /*  Now process the command line arguments. 
     */
    if (VOD_DEBUG) {
        fprintf (stderr, "Command:");
        for (i=0; i < argc; i++) fprintf (stderr, " '%s'", argv[i]);
        fprintf (stderr, "\n");
        for (i=0; i < argc; i++) fprintf (stderr, "%s ", argv[i]);
        fprintf (stderr, "\n\n");
    }



    /*  Parse the argument list.  
     */
    pargv = vo_paramInit (argc, argv, opts, long_opts);
    for (i=1; i < argc; i++) {

	memset (optval, 0, SZ_FNAME);
	ch = vo_paramNext (opts, long_opts, argc, pargv, optval, &pos);
#ifdef PARAM_DBG
	fprintf (stderr, "ch = '%c' %d  optval = '%s'\n", 
  	    ch, ch, (optval[0] ? optval : "N/A"));
#endif

        if (ch > 0) {
            switch (ch) {
 	    case '?':				/* unknown		*/
		break;

 	    case 'h':				/* help			*/
		Usage ();
    		voc_closeVOClient (0);
		return (OK);

 	    case '%':				/* unit tests		*/
    		voc_closeVOClient (0);			
		Tests (optval);
		return (self.nfail);

            case 'N':				/* numeric output name	*/
		numout++;
		break;
            case 'S':				/* simple output name	*/
		simple_out++;
		break;

            case 'A':				/* ASCII output		*/
		format = F_ASCII;
		break;
            case 'C':				/* CSV output		*/
		format = F_CSV;
		break;
            case 'F':    			/* FITS table output	*/
		fprintf (stderr,
		    "FITS tables not yet implemented, using ASCII\n");
		format = F_ASCII;           
		break;
            case 'H':				/* HTML output		*/
                extract |= EX_HTML;
		format = F_CSV | F_HTML;   
		if (output && output[0] == '-')
                    extract |= EX_COLLECT;
		break;
#ifdef VO_INVENTORY
            case 'I':				/* inventory count	*/
		inventory++;
		count++;
		break;
#endif
            case 'K':				/* KML output		*/
                extract |= EX_KML;
		format = F_CSV | F_KML;    
		break;
            case 'R':				/* RAW output		*/
            case 'V':				/* VOTable output	*/
		format = F_RAW;
		if (output && output[0] == '-')
                    	extract |= EX_COLLECT;
		break;
            case 'T':				/* TSV output		*/
		format = F_TSV;
		break;
            case 'X':				/* XML output		*/
                extract |= EX_XML;
		format = F_RAW | F_XML;    
		if (output && output[0] == '-')
                    extract |= EX_COLLECT;
		break;

            case 'O':    			/* root output name	*/
		//VOT_NEXTARG(argc,argv,i);
		output = strdup (optval);
		if (output[0] == '-') {
		    wr_stdout++;
		    quiet++;				
		    if ((extract & EX_XML) || (extract & EX_KML))
                    	extract |= EX_COLLECT;

		    memset (wrkdir, 0, SZ_FNAME);
		    sprintf (wrkdir, "%s/vod%d", tmpdir, (int)getpid());
		    if (access (wrkdir, R_OK|W_OK) != 0)
			mkdir (wrkdir, (mode_t)0666);
		    chdir (wrkdir);
		}
		break;

            case 'a':    			/* all data 		*/
		all_data++;				
		res_all++;
		/*sr = -1.0; */			/* flag to get all data */
		break;
            case 'b':				/* forced type string	*/
		if (optval[0] == '/' || isdigit(optval[0]))
		    d2_band = strdup (optval);
		else 
		    if (strncasecmp (optval, "any", 3) != 0)
		        bpass = strdup (optval);
		break;
            case 'c':    
		count++;				
		count_only = TRUE;
		break;

            case 'e':    			/* extract pos/acrefs?	*/
		if (strncmp (optval, "pos", 3) == 0)
		    extract |= EX_POS;
		else if (strncmp (optval, "url", 3) == 0)
		    extract |= EX_ACREF;
		else if (strncmp (optval, "head", 4) == 0)
		    extract |= EX_HTML;
		else if (strncmp (optval, "kml", 3) == 0)
		    extract |= EX_KML;
		else if (strncmp (optval, "xml", 3) == 0)
		    extract |= EX_XML;
		else if (strncmp (optval, "all", 3) == 0)
                    extract  = EX_ALL;
		else 
                    extract  = EX_ALL, i++;
		break;

            case 'f':    			/* force table read	*/
		force_read++;
		break;

            case 'g':			/* get specific results */    
		extract |= EX_ACREF;
		fileRange.nvalues = RANGE_ALL;
		file_get = RANGE_ALL;
		break;

            case 'i':		/* take remaining args from file */    
		VOT_NEXTARG(argc,argv,i);
		sv_apos = apos;
		argfile = strdup (argv[++i]);
		if (argfile[0] == '-') {
		    if (strlen (argfile) > 1) {
			fprintf (stderr, "ERROR: the '-i' flag requires ");
			fprintf (stderr, "a filename or '-' for stdin\n");
			exit (1);
		    } else if (rd_stdin) {
			fprintf (stderr,
				"ERROR: stdin can only be used once\n");
			exit (1);
		    } else {
			rd_stdin++;
			arg_fd = stdin;
		    }

		} else {
		    if (access (argfile, R_OK) == 0) {
		        /* Open the file, we'll process it below. 
		        */
		        if ((arg_fd = fopen(argfile,"r")) == (FILE *)NULL) {
		            fprintf (stderr,
				    "ERROR: Cannot open file '%s'\n", argfile);
		            return (ERR);
		        }
		    }
		}
		break;

            case 'M':			/* verbose meta 	*/
		meta++, verbose = 3;
		res_all++;
		break;
            case 'm':			/* meta flag		*/
		meta++;
		res_all++;
		break;

            case 'n':			/* no-save results	*/
		save_res = FALSE;
		count_only = TRUE;
	 	break;

            case 'o':			/* query object name	*/
		VOT_NEXTARG(argc,argv,i);
		use_name++;
		next_arg = argv[i+1];
		if (next_arg[0] == '-') {
		    if (rd_stdin) {
                        fprintf (stderr,
                            "ERROR: stdin can only be used once\n");
                        exit (1);

		    } else {
                        rd_stdin++;
		    	fixed_obj++;
			vot_readObjFile ("-");
		    }
		    i++;			/* advance argv 	*/
		} else if (inventory) {
		    vot_parseObjectList (argv[++i], TRUE);
		    sources = strdup (argv[i]);
		    if (debug)
			fprintf (stderr, "setting 'obj' sources = '%s'\n",
			    sources);
		    apos++;
		} else
		    vot_parseObjectList (argv[++i], TRUE);
		if (svcList)
		    apos++;
		break;

            case 'p':				/* query position	*/
		//VOT_NEXTARG(argc,argv,i);
		next_arg = argv[i+1];
		memset (posn, 0, SZ_LINE);
		if (next_arg[0] == '-') {
		    if (strlen (next_arg) > 1) {
			fprintf (stderr,"ERROR: the '-p' flag requires");
			fprintf (stderr," coords or '-' for stdin\n");
			return (ERR);
                    } else if (rd_stdin) {
                        fprintf(stderr, "ERROR: stdin can only be used once\n");
                        exit (1);
		    } else {
                        rd_stdin++, fixed_pos++;
			vot_readObjFile ("-");
		    }
		    i++;			/* advance argv 	*/
		} else {
		    if (isSexagesimal(optval) || isDecimal(optval)) {
		        vot_parseObjectList (optval, TRUE);
		    } else if (inventory) {
		        vot_parseObjectList (optval, TRUE);
			sources = strdup (optval);
			if (debug)
			    fprintf (stderr, 
				"setting pos sources='%s'\n", sources);
		    } else
		        vot_parseObjectList (optval, TRUE);
		    fixed_pos++;
		}
		break;

            case 'q':
		quiet++;				
		break;

            case 'r':  			/* search radius	*/
		VOT_NEXTARG(argc,argv,i);
		sr = vot_atof (argv[++i]);
		break;

            case 's':			/* data service		*/
		VOT_NEXTARG(argc,argv,i);
		if (strncmp (argv[i+1], "http", 4) == 0)
		   force_svc++;
		next_arg = argv[i+1];
		if (next_arg[0] == '-') {
		    if (strlen (next_arg) > 1) {
			fprintf(stderr,"ERROR: the '-s' flag requires ");
			fprintf(stderr,"a service name or '-' for stdin\n");
			exit (1);
		    } else
			vot_readSvcFile ("-", dalOnly);
		    i++;			/* advance argv 	*/
		} else if (isdigit (argv[i+1][0])) {
		    svcNumber = vot_atoi (argv[++i]);
		    vot_parseServiceList ((resources = strdup (argv[++i])), 
			dalOnly);
		    if (debug)
			fprintf (stderr, "setting resources = '%s'\n",
			    resources);
		} else {
		    vot_parseServiceList ((resources = strdup (argv[++i])), 
			dalOnly);
		    if (debug)
			fprintf (stderr, "setting resources = '%s'\n",
			    resources);
		}
		fixed_svc++;
		apos++;
		break;

            case 't':			/* forced type string	*/
		//VOT_NEXTARG(argc,argv,i);
		if (strncasecmp (optval, "any", 3) != 0)
		    typestr = strdup (optval), i++;
		break;

            case 'u':			/* forced url download	*/
		url_proc++;
		break;

            case 'v':			/* verbose flag		*/
		verbose = min(3,(verbose+1));
		break;
            }

        } else if (ch == 0) {
	    if ((ch=vot_setArgWord((char *)long_opts[pos].name, optval)) == 0) {
		fprintf (stderr, "unknown long option '%s'\n", 
		    long_opts[pos].name);
		status = ERR;
		goto cleanup_;
            }


#ifdef ENG_FLAGS
        } else if (argv[i][0] == '+') {
            len = strlen (argv[i]); 		/* "Engineering" flags.  */
            for (j=1; j < len; j++) {
                switch (argv[i][j]) {
                case 's':    
		    table_hskip = vot_atoi (argv[++i]);
		    break;
                case 'S':    
		    samp++;				
		    sampName = strdup (argv[++i]);
		    break;
                case 'i':    
		    iportal++;				
		    break;
                case 'd':    
		    debug++;				
		    break;
                case 'l':    
		    svc_list = 1;
		    obj_list = 1;
		    break;
                case 'q':    
		    quiet = 0;
		    break;
                case 'a':    			/* null all flag	*/
		    break;
                case 'n':    			/* null flag		*/
		    break;

#ifdef REG10_KLUDGE
                case 'r':    
		    reg10++;				
		    break;
#endif
                case 'r':    
		    raw_vizier = TRUE;				
		    break;
                case 't':    
		    tmpdir = strdup (argv[++i]);
		    break;
                case 'v':    
		    dverbose++;				
		    break;
                }
            }
#endif

        } else {
	    /* Parse the arguments according to an assumed calling 
	    ** order, e.g.
	    **
	    **	  vodata [ url_list | [ resource [obj | ra dec] [sr] ]
	    **
	    ** By default we assume 'sr' is in degrees, the ra/dec will
	    ** be assumed to be ICRS J200 and may be sexagesimal or decimal.
	    ** Since we're parsing the argv[], be sure to take into account
	    ** any increments added because of consumed arguments.
	    */
	    int  inc = 0;

    	    for ( ; i < argc; i++) {
//if (i > 2 && apos == 0) i--;
//fprintf (stderr, "pos: '%s' '%s' apos=%d i=%d\n", argv[i], argv[i+1], apos, i);
	        if (vot_parseArgToken (argv[i], argv[i+1], apos, &inc) != OK) {
	    	    exit (1);
	        } else 
	            i += inc;		/* add the argv[] increment  	*/

	        apos++;			/* update arg position		*/
    	    }
	}
    }
    re_time = time ((time_t) NULL);


    /* Close VOClient connection.  Each child process will need to reopen
    ** their own connection, and if we're processing an argument file we'll
    ** open/close it again as needed.
    */
    voc_closeVOClient (0);			


    /*  If we're broadcasting the result tables, open the SAMP connection
    **  now and let the child processes simply send the message.
    if (samp) {
        samp_p = sampInit ((sampname ? sampName : "VOData"), 
	    "VOClient Data Access");
        samp_setSyncMode (samp_p);
        sampStartup (samp_p);
    }
    */

    
    /*  The control logic below allows us to process more than one
    **  "command-line".  If we got our services and objects from the 
    **  true command-line the loop will break at the bottom and we only
    **  execute once.  The service and object lists were created when
    **  processing the arguments above.  OTOH, if we're using an argument
    **  file, those lists are now NULL and we'll read each line of the
    **  argfile and create them now.  In either case, we clean up and
    **  reset the lists at the bottom of the loop.
    */
    
    while (1) {
    
	/*  If we're processing from the stdin or an argument file, 
	**  get the next line of the file and fake the commandline to
	**  set the resource and object lists.  Note we clean up and
	**  reset below to permit each iteration to process a different
	**  number of resources or objects.
	*/
        if (arg_fd) {
    	    if (vot_getNextCmdline () != OK)
		break;
	}
    
    	
        /*  Tally up the the number of services and objects to be queried.
        */
        if ((nservices = vot_countServiceList()) == 1) 
	    svc_list = 0;
        if ((nobjects = vot_countObjectList()) == 1)
	    obj_list = 0;
    
#ifdef VO_INVENTORY
	/*  If we're calling the Inventory service, branch to do it here and
	**  then continue with the loop.
	*/
	if (inventory) {
	    if (debug)
		fprintf (stderr, "inventory nserv = %d    nobj = %d\n",
		    nservices, nobjects);

	    if (nobjects == 0 && sources == NULL) {
		fprintf (stderr, "No object position(s) specified.\n");
		exit (1);

	    } else {
    	        vot_printSvcHdr ();
    		qs_time = time ((time_t) NULL);
		(void) vot_doInventory ();
    		qe_time = time ((time_t) NULL);
	    }

            vot_printProcTime ();
	    break;
	}
#endif

        /*  If we have services to call and aren't simply downloading URLs,
        **  process the service queries first.
        */
        if (svcList && !url_proc) {
    
            /* See whether any flags negate other options.
            */
    	    if (vot_validateOptions() == ERR)
		break;
    
            /* Print header information.
            */
    	    vot_printSvcHdr ();
    
            /* Now run the serice queries.  Each service is run on a separate
            ** thread, we'll handle summary output and any postprocessing later.
            */
            vot_runSvcThreads ();
        }
    
        /*  Process the access reference list to download any pending data.
        */
        if (acList && nacrefs)
    	    vot_procAclist ();
    
        /*  Free up any memory we may have allocated.  Counters and pointers
	**  are reset in each routine.
        */
        vot_freeAclist ();		/* access reference list	*/
        vot_freeObjectList ();		/* object list			*/
	if (sv_apos < 0)
            vot_freeServiceList ();	/* VO resource list		*/
	else
            vot_resetServiceCounters ();
    

        /*  Print an approximate summary of the processing time required.
        */
        vot_printProcTime ();

	/*  If we're not processing from an argument file or the 
	**  stdin, we've processed the argv from the commandline, so
	**  break here.
	*/
        if (!arg_fd)
    	    break;
    }


cleanup_:
    if (arg_fd && arg_fd != stdin)	/* close the argument file	*/
	fclose (arg_fd);
			
    if (wr_stdout && wrkdir[0] && access (wrkdir, R_OK|W_OK) == 0)
	rmdir (wrkdir); 		/* clean up wrkdirs		*/

    /*
    if (samp)
	samp_UnRegister (samp_p);
    */

    if (bpass)    free ( (void *) bpass);
    if (typestr)  free ( (void *) typestr);

    if (d2_band)    free ( (void *) d2_band);
    if (d2_time)    free ( (void *) d2_time);
    if (d2_format)  free ( (void *) d2_format);
    if (d2_version) free ( (void *) d2_version);

    return ( status );
}




/*  Set an argument that may optionally be specified as an entire word.
*/

#define	ARG_DONE	-1

static char
vot_setArgWord (char *arg, char *val)
{
#ifdef PARAM_DBG
    fprintf (stderr, "setArg = '%s'  val = '%s'\n", arg, val);
#endif

    if (arg[0] == '-') {
	fprintf (stderr, "Invalid argument string '--'\n");
	return (0);
						/* '--' only  FLAGS	*/
    } else if (strncmp (arg, "debug", 5) == 0) {
	debug++;
    } else if (strncmp (arg, "vdebug", 6) == 0) {
	debug=3;
    } else if (strncmp (arg, "bandpass", 8) == 0) {
	bpass = vot_requiredArg (val);

    } else if (strncmp (arg, "cols", 4) == 0) {
	cols = vot_requiredArg (val);

    } else if (strncmp (arg, "delim", 5) == 0) {
	delim = vot_requiredArg (val);
	switch (delim[0]) {
	case 's':	delim = " ";  break;
	case 'c':	delim = ",";  break;
	case 't':	delim = "\t"; break;
	case 'b':	delim = "|";  break;
	}

    } else if (strncmp (arg, "extract", 7) == 0) {

        if (!val) {			    	/* just "--extract"	*/
           extract |= EX_ALL;

        } else {
           switch (*val) {
            case 'h':   extract |= EX_HTML;         break;  /* html         */
            case 'k':   extract |= EX_KML;          break;  /* KML          */
            case 'K':   extract |= EX_KML;
                        extract |= EX_COLLECT; 	    break;  /* one-file KML */
            case 'p':   extract |= EX_POS;          break;  /* positions    */
            case 'u':   extract |= EX_ACREF;        break;  /* urls         */
            case 'X':   extract |= EX_XML;
                        format   = (F_RAW | F_XML);
                        extract |= EX_COLLECT;      break;  /* one-file XML */
            default:    extract  = EX_BOTH;         break;  /* all          */
            }
	}

    } else if (strncmp (arg, "ecols", 5) == 0) {
	ecols = vot_requiredArg (val);

    } else if (strncmp (arg, "get", 3) == 0) {
	char *ip = vot_optionalArg (val);

	extract |= EX_ACREF;
	if (ip == NULL || !(isdigit(*ip)) ) {
            /* No option implies we get all rows.
            */
            fileRange.nvalues = RANGE_ALL;
            file_get = RANGE_ALL;
	} else {
	    /* Next arg is a range string.
	    */
	    strcpy (fileRange.rstring, ip);
	    if (vot_decodeRanges (fileRange.rstring,
		fileRange.ranges, MAX_RANGES, &fileRange.nvalues) < 0) {
		    fprintf (stderr, "Error decoding range string.\n");
	    }
	    file_get = fileRange.nvalues;

	    free ( (void *) ip);
	}

    } else if (strncmp (arg, "hskip", 5) == 0) {
	char *ip = vot_optionalArg (val);
	if (ip) {
	    table_hskip = vot_atoi ( ip );
	    free ( (void *) ip);
	}

    } else if (strncmp (arg, "kml", 3) == 0) {
	char *ip = vot_requiredArg (val);

        switch (arg[3]) {
        case 'm':                   /* max placemarks   --kmlmax=N 	*/
            kml_max = vot_atoi(val);
            break;
        case 'g':		    /* grouping		--kmlgroup=type */
            switch (*val) {
            case 'b':               /* group by both        */
                kml_byBoth = TRUE;
                kml_byObj = FALSE, kml_bySvc = FALSE;
                break;
            case 'o':               /* group by object      */
                kml_byObj = TRUE;
                kml_byBoth = FALSE, kml_bySvc = FALSE;
                break;
            case 's':               /* group by service     */
                kml_bySvc = TRUE;
                kml_byObj = FALSE, kml_byBoth = FALSE;
                break;
            }
            break;
        case 's':                   /* sample placemarks --kmlsample=N 	*/
            kml_sample = vot_atoi(ip);
            break;

        case 'n':                   /* sample placemarks --kmlno<opt> 	*/
            switch (arg[5]) {
            case 'l':                   /* disable labels       */
                kml_label = FALSE;
                break;
            case 'r':                   /* disable region box   */
                kml_region = FALSE;
                break;
            case 'v':                   /* disable verbose label*/
                kml_verbose = FALSE;
                break;
            }
        }

        if (strncmp (val, "kmlgroup", 8) == 0)
            extract |= EX_KML;
	if (ip) 
	    free ((void *) ip);

    } else if (strncmp (arg, "max", 3) == 0) {
	char *ip = vot_requiredArg (val);

        switch (arg[3]) {
        case 'd':			/* --maxdownloads=<N>	*/
            max_download = vot_atoi(ip);
            max_download = min(MAX_DOWNLOADS,max_download);
            break;
        case 'p':			/* --maxprocs=<N>	*/
            max_procs = vot_atoi(ip);
            max_procs = min(MAX_PROCS,max_procs);
            break;
        case 't':			/* --maxthreads=<N>	*/
            max_threads = vot_atoi(ip);
            max_threads = min(MAX_THREADS,max_threads);
            break;
        }

    } else if (strncmp (arg, "nlines", 6) == 0) {
	char *ip = vot_requiredArg (val);
	table_nlines = vot_atoi ( ip );
	if (ip) 
	    free ((void *) ip);

    } else if (strncmp (arg, "object", 6) == 0) {
	char *ip = vot_requiredArg (val);

        use_name++;
        if (!ip || ip[0] == '-') {
            if (rd_stdin) {
                fprintf (stderr, "ERROR: stdin can only be used once\n");
                exit (1);

            } else {
                rd_stdin++;
                fixed_obj++;
                vot_readObjFile ("-");
            }
        } else if (inventory) {
            vot_parseObjectList (ip, TRUE);
            sources = ip;
            if (debug)
                fprintf (stderr, "setting 'obj' sources = '%s'\n", sources);
            apos++;
        } else
            vot_parseObjectList (ip, TRUE);
        if (svcList)
            apos++;
	if (ip) 
	    free ((void *) ip);

    } else if (strncmp (arg, "output", 6) == 0) {
	char *ip = vot_requiredArg (arg);

        output = (ip ? ip : "=");
        if (output[0] == '-') {
            wr_stdout++;
            quiet++;                                
            if ((extract & EX_XML) || (extract & EX_KML))
                extract |= EX_COLLECT;

            memset (wrkdir, 0, SZ_FNAME);
            sprintf (wrkdir, "%s/vod%d", tmpdir, (int)getpid());
            if (access (wrkdir, R_OK|W_OK) != 0)
                mkdir (wrkdir, (mode_t)0666);
            chdir (wrkdir);
        }
	if (ip) 
	    free ((void *) ip);

    } else if (strncmp (arg, "pos", 3) == 0) {
	char posn[SZ_LINE];
	char *ip = vot_requiredArg (val);

        if (ip[0] == '-') {
            if (strlen (ip) > 1) {
                fprintf (stderr,"ERROR: the '--pos' flag requires ");
                fprintf (stderr,"coords or '-' for stdin\n");
                exit (1);
            } else if (rd_stdin) {
                fprintf (stderr, "ERROR: stdin can only be used once\n");
                exit (1);
                rd_stdin++, fixed_pos++;
            } else {
                vot_readObjFile ("-");
            }
        } else {
	    char v1[SZ_FNAME], v2[SZ_FNAME], *op;

	    op = strchr (val, (int)',');   /* find delimiter  	*/
	    memset (v1, 0, SZ_FNAME);	   /* clear arrays    	*/
	    memset (v2, 0, SZ_FNAME);
	    if (op) {
		*op = '\0';
		strcpy (v1, ip);	   /* first arg		*/
		strcpy (v2, op+1);	   /* second arg	*/
	    } else {
                fprintf (stderr, "ERROR: Invalid '--pos' argument\n");
                exit (1);
	    }

            if (isSexagesimal(v1) || isDecimal(v1)) {
                sprintf (posn, "%s %s", v1, v2);
                fixed_pos++;
                vot_parseObjectList (posn, TRUE);
            } else if (inventory) {
                vot_parseObjectList ((sources = ip), TRUE);
                apos++;
            } else
                vot_parseObjectList (ip, TRUE);
        }
	if (fixed_svc)
            apos++;
	if (ip) 
	    free ((void *) ip);

    } else if (strncmp (arg, "sample", 6) == 0) {
	table_sample = vot_atoi ( vot_requiredArg (arg) );

    } else if (strncmp (arg, "sr", 2) == 0) {
	char *ip = vot_requiredArg (val);
	int  len = strlen(ip);
	char units = ip[len-1];

	if (!isdigit(units))
	    ip[len-1] = '\0';
	else
	    units = 'd';
        switch (units) {
        case 's':  sr = vot_atof (ip) / 3600.; 	break;
        case 'm':  sr = vot_atof (ip) / 60.; 	break;
        case 'd':  sr = vot_atof (ip); 		break;
        }
	if (ip) 
	    free ((void *) ip);


    } else if (strncmp (arg, "svc", 3) == 0) {
	char *ip = vot_requiredArg (val);

        if (strncmp (ip, "http", 4) == 0)
            force_svc++;
        if (ip[0] == '-') {
            if (strlen (ip) > 1) {
                fprintf (stderr,"ERROR: the '-s' flag requires ");
                fprintf (stderr,"a service name or '-' for stdin\n");
                exit (1);
            } else
                vot_readSvcFile ("-", dalOnly);
        } else {
            vot_parseServiceList ((resources = ip), dalOnly);
            if (debug)
                fprintf (stderr, "setting resources = '%s'\n", resources);
            if (inventory)
                apos++;
	}
        fixed_svc++;
        apos++;
	if (fixed_pos)
            apos++;
	if (ip) 
	    free ((void *) ip);

    } else if (strncmp (arg, "type", 4) == 0) {
	typestr = vot_requiredArg (val);

    } else if (strncmp (arg, "verbose",  7) == 0) {
	verbose = 2;
    } else if (strncmp (arg, "vverbose",  8) == 0) {
	verbose = 3;

    } else if (strncmp (arg, "onefile",  7) == 0) {
	extract |= EX_COLLECT;			/* one-file output	*/

    } else if (strncmp (arg, "wb", 2) == 0 || 
	strncmp (arg, "webnoborder", 9) == 0) {
            html_border = FALSE;  		/* disable table border    */
    } else if (strncmp (arg, "webborder", 7) == 0) {
            html_border = TRUE;  		/* enable table border     */

    } else if (strncmp (arg, "wc", 2) == 0 ||
	strncmp (arg, "webnocolor", 9) == 0) {
            html_color = FALSE;   		/* disable border color    */
    } else if (strncmp (arg, "webcolor", 9) == 0) {
            html_color = TRUE;   		/* enable border color     */

    } else if (strncmp (arg, "wh", 2) == 0 ||
	strncmp (arg, "webnoheader", 9) == 0) {
            html_header = FALSE;   		/* disable table header    */
    } else if (strncmp (arg, "webheader", 7) == 0) {
            html_header = TRUE;   		/* enable table header     */


    } else if (strncmp (arg, "web", 3) == 0) {
	char *ip = vot_requiredArg (val);
        switch (ip[0]) {
        case 'b':   html_border = FALSE; break;  /* disable table border    */
        case 'c':   html_color  = FALSE; break;	 /* disable verbose label   */
        case 'h':   html_header = FALSE; break;	 /* disable region box	    */
	}
	if (ip) 
	    free ((void *) ip);
						/* DAL2 OPTION FLAGS	*/
    } else if (strncmp (arg, "band", 4) == 0) {
	d2_band = vot_requiredArg (val);
    } else if (strncmp (arg, "time", 4) == 0) {
	d2_time = vot_requiredArg (val);
    } else if (strncmp (arg, "format", 6) == 0) {
	d2_format = vot_requiredArg (val);
    } else if (strncmp (arg, "version", 7) == 0) {
	d2_version = vot_requiredArg (val);
    }

    return (ARG_DONE);
}


static char *
vot_requiredArg (char *arg)
{
    if (! arg) {
        fprintf (stderr, "ERROR: Missing '--%s' argument.\n", arg);
        exit (1);
    }

    return ( strdup (arg) );
}

static char *
vot_optionalArg (char *arg)
{
    return ( (arg ? strdup (arg) : NULL) );
}



/************************************************************************
**  PARSEARGTOKEN -- Parse the argument based on it's position on the 
**  command line.  Some actions will require the next argument in the 
**  command, otherwise the 'next' pointer will usually be NULL.  This 
**  routine can be used to parse either the argv commands or those from 
**  a file.  The 'inc' variable will indicate how far to advance the 
**  argument counter as a result of this procedure.
*/
static int
vot_parseArgToken (char *arg, char *next, int pos, int *inc)
{
    char posn[64];

    *inc = 0;

    /* Parse the arguments according to an assumed calling 
    ** order, i.e.
    **
    **	  vodata [ url_list | [ resource [obj | ra dec] [sr] ]
    **
    ** By default we assume size is in degrees, the ra/dec will
    ** be assumed to be ICRS J200 and may be sexagesimal or decimal.
    */
//fprintf (stderr, "parseArg:  '%s' '%s' %d apos=%d\n", arg, next, pos, apos);
    switch (apos) {
    case 0:				/* <resource> | <url>	*/

	if (arg[0] != '/' && (isSexagesimal (arg) || isDecimal (arg))) {
    	    fprintf (stderr,
	      "\nERROR: First argument required to be resource or url.\n");
    	    return (ERR);
	}

	if (strncmp (arg, "http", 4) == 0 && !force_svc && url_proc) {
	    /* If this is a simple URL, simply download the result. */
	    vot_addToAclist (arg, NULL);
	    if (!fixed_pos)
	        apos--;
	    url_proc++;

#ifdef VO_INVENTORY
	} else if (inventory) {
	    /* If we're doing an incentory call, the first arg is only
	    ** allowed to be either 'any', and 'ivorn', or (eventually) a
	    ** file of resources to be uploads.
	    */
	    if (strcasecmp ("any",arg) == 0 ||
		strncmp (arg, "ivo://", 6) == 0 ||
		access (arg, R_OK) == 0) {
		    if (strncmp (arg, "ivo://", 6) == 0) {
			extern char *id;
			id = arg;
		    }
		    if (access (arg, R_OK) == 0)
		        resources = arg;
                    vot_parseServiceList (arg, 0);

	    } else {
		fprintf (stderr, "Invalid resource type for Inventory, '%s'\n",
		    arg);
		exit (1);
	    }
#endif

	} else if (raw_vizier && strncmp ("ivo://CDS", arg, 9) == 0) {
	    char  url[SZ_LINE];
	    char *res = &arg[17];
	    char *base =
		"http://vizier.u-strasbg.fr/viz-bin/votable/-dtd/-A?-source=";

	    sprintf (url, "%s%s", base, res);

	    /* 
	    */
	    vot_parseServiceList (url, 0);
	    if (!fixed_pos)
	        apos--;
	    url_proc++;

	} else {
	    /*  Restrict 'any' searches to DAL only to save time.
	     */
	    if (strncasecmp ("any", arg, 3) == 0)
		dalOnly = 1;
	    vot_parseServiceList (arg, dalOnly);
	    if (fixed_pos)
	        apos++;
	}

	break;

    case 1:				/* <obj> | <pos>*/
	/* Sanity checks.  */
	if (force_svc && typestr && strchr(typestr,(int)',')) {
    	    fprintf (stderr,
	      "\nERROR: Only one type may be given to used-defined service.\n");
    	    return (ERR);

	} else if (force_svc && !typestr && !fixed_svc) {
    	    fprintf (stderr,
	      "\nERROR: No type specified for used-defined service.\n");
    	    return (ERR);

	} else if (!url_proc && !svcList && !inventory) {
	    fprintf (stderr,
		"\nERROR: No supported DAL service types found.\n");
	    return (ERR);
	}

	/* Parse the object or position.  */
	if (fixed_pos) {
	    *inc = 1;
	} else if (isSexagesimal (arg) || isDecimal (arg)) {
	    memset (posn, 0, 64);
	    sprintf (posn, "%s %s", arg, next);
	    vot_parseObjectList (posn, TRUE);
	    *inc = 1;
	} else {
	    use_name++;
	    if (inventory && access (arg, R_OK) == 0)
		sources = arg;
	    vot_parseObjectList (arg, TRUE);
	}
	break;

    case 2:				/* <size> (degrees)	*/
	sr = vot_atof (arg);
	break;

    default:
	fprintf (stderr, "Warning: Unknown argument syntax\n");
	vot_printUsage ();
	return (ERR);
    }

    return (OK);
}


/************************************************************************
**  GETNEXTCMDLINE -- Process the next command line from the argument 
**  file.  We do this by reading a line of the file and tokenizing it
**  as if the values were given to us on the command-line.  For the 
**  moment we don't allow options to be set and permit only the positional
**  arguments (e.g. resource, object, coords).
*/
static int
vot_getNextCmdline ()
{
    int   i, inc;
    char  *tok, *sep = " ", *line, cmdline[SZ_LINE];
    int   a_argc = 0;
    char  a_argv[4][SZ_LINE];

    extern char *vot_getline (FILE *fd);


    memset (a_argv, 0, (4 * SZ_LINE));
    memset (cmdline, 0, SZ_LINE);

    if (( line =  vot_getline (arg_fd)))
        strcpy (cmdline, line);
    else
        return (ERR);


    for (tok = strtok(cmdline, sep); tok; tok = strtok(NULL, sep)) {
	strcpy (a_argv[a_argc++], tok);
    }

    if (voc_initVOClient ("runid=voc.vodata") == ERR) 
        exit (-1);

    apos = sv_apos;
    for (i=0; i < a_argc; i++) {
        if (vot_parseArgToken (a_argv[i], a_argv[i+1], apos, &inc) != OK) {
    	    exit (1);
        } else 
            i += inc;		/* add the argv[] increment  	*/

        apos++;			/* update arg position		*/
    }


    /* Close the VOClient connection since each child will use its own.
    */
    voc_closeVOClient (0);			/* close VOClient connection */

    return (OK);
}


/************************************************************************
**  VALIDATEOPTIONS -- Verify that all the commandline options make sense 
**  before we begin processing.  Some options will require others and we 
**  can only check after all the options have been set and parsed from 
**  the command line.
*/
static int
vot_validateOptions ()
{
    if (count)
	fileRange.nvalues = RANGE_NONE;

    if (nobjects < 1) {
	if (apos && !meta && !all_data) { 
	    /* User provided an object, but it was invalid.
	    */
	    fprintf (stderr, "Error: No valid position or object found.\n");
	    return (ERR);

	} else {
	    /* No position/object supplied, use default.
	    */
	    if (!quiet && !meta) 
	        fprintf (stderr, "# Using default position: 0.0 0.0\n");
	    vot_parseObjectList ("0.0 0.0", TRUE);
    	    nobjects = vot_countObjectList();
	}
    }

    if (output && output[0] == '-')
	extract |= EX_COLLECT;

    if (kml_sample)
	kml_max *= kml_sample;

    if (meta && nservices == 0) {
	fprintf (stderr, "ERROR: No service specified.\n");
	return (ERR);
    } else if (meta && nservices == 1) {
	output = "-";
	wr_stdout++;
	quiet++;				
    }

    return (OK);
}



/************************************************************************
**  PRINTSVCHDR -- Print a header for service output.
*/
void
vot_printSvcHdr ()
{
    if (!quiet) {
	printf ("\n");
        if (meta) {
	    if (nservices == 1)
	        fprintf (stderr, "# Service:  %s\n", svcList->name);
	    fprintf (stderr, "# No. of Services: %d\n", nservices);
	} else {
	    if (nservices == 1) {
	        fprintf (stderr, "# Service:  %s\n", svcList->name);
	        fprintf (stderr, "# Title:  %s\n", svcList->title);
	    }
	    fprintf (stderr, "# No. of Objects:  %d\n", nobjects);
	    fprintf (stderr, "# No. of Services: %d\n", nservices);
	}
	fprintf (stderr, "# Search size:  %f (degrees)\n#\n", sr);
        if (count || inventory) 
	    vot_printCountHdr ();
    }

    fflush (stdout);
}


/************************************************************************
**  RUNSVCTHREADS --  Begin a processing thread for each data service.  We
**  split the object list over each service in parallel threads.
*/
static void
vot_runSvcThreads ()
{
    int     t, tc, rc, status, t_start, t_end, nthreads;
/*
    pthread_t  thread[nservices];
*/
    static pthread_t  thread[10000];
    Service *svc = svcList;
    Proc    *new = (Proc *)NULL;
    Proc    *cur = (Proc *)NULL;
    pthread_attr_t  attr;		/* thread attributes		*/


    qs_time = time ((time_t) NULL);

    if (verbose && !count && !meta && nservices > 1)
	fprintf (stderr, "# Creating service processing threads...\n");

    /* Pre-allocate the process lists so they're in the global memory
    ** space.
    */
    for (svc=svcList; svc; svc=svc->next) {
	for (t=0; t < nobjects; t++) {
	    new = (Proc *) calloc (1, sizeof (Proc));
	    new->svc = (Service *) svc;		/* set back pointer	*/
	    if (t == 0) {
		svc->proc = new;
		cur = svc->proc;
	    } else {
		cur->next = new;
		cur = cur->next;
	    }
	}
    }

    nthreads = min (nservices, max_threads);
    t_start = 0;
    t_end   = nthreads;


    /* Spawn the processing threads.
    */
    svc = svcList;
    for (tc=0; tc < nservices; tc += nthreads) {
        t_end   = min((nservices-tc),nthreads);

        /* Initialize the service processing thread attributes and run 'em.
        */
        pthread_attr_init (&attr);
        pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_JOINABLE);

        for (t=0; t < t_end; t++, svc=svc->next) {
	    if ((rc = pthread_create (&thread[t], &attr, vot_procObjs, 
		(void *)svc))) {
	            fprintf (stderr,
			"ERROR: pthread_create() fails, code: %d\n", rc);
	            exit (-1);
	    }
        }

        /* Free attribute and wait for the threads to complete.
        */
        for (t=0; t < t_end; t++) {
	    if ((rc = pthread_join (thread[t], (void **)&status)) ) {
		/*
	        fprintf (stderr, "ERROR: pthread_join() fails, code: %d\n", rc);
	        exit (-1);
		*/
		;
	    }
        }

        pthread_attr_destroy (&attr);
    }
    qe_time = time ((time_t) NULL);

    if ((debug && verbose > 1)) {
	fprintf (stderr, "\n\n..........THREAD PROCS COMPLETED.....\n");
	vot_printSvcList (svcList);
	fprintf (stderr, "..........THREAD PROCS COMPLETED.....\n\n\n");
    }


    /*  If we're only writing a KML file and not simply extracting them
    **  as an extra, concatenate the results from each query to a single
    **  file for easier browsing.
    */
    if (format & F_KML || (extract & EX_KML && extract & EX_COLLECT)) {
 	char  fname[SZ_FNAME];
	extern void vot_concatKML (char *fname);

	memset (fname, 0, SZ_FNAME);
	if (output && output[0] != '-')
	    sprintf (fname, "Query_%d.kml", (int)getpid());
	else
	    strcpy (fname, "-");
	if (nservices > 1 && nobjects > 1)
	    vot_concatKML (fname);	

    } else if (format & F_XML || (extract & EX_XML && extract & EX_COLLECT)) {
 	    char  fname[SZ_FNAME];
	    extern void vot_concatXML (char *fname);

	    memset (fname, 0, SZ_FNAME);
	    if (output && output[0] != '-')
	        sprintf (fname, "Query_%d.xml", (int)getpid());
	    else
	        strcpy (fname, "-");

	    if (nservices > 1 && nobjects > 1)
	        vot_concatXML (fname);	

    } else if (extract & EX_COLLECT) {
	extern void vot_concat (void);

	vot_concat ();			/* concatenate results		*/
    }


    /* For verbose output, print a summary of the processing history.
    */
    if (!quiet && count && !meta) {
        Proc *curproc  = (Proc *) NULL;
        Proc *proc  = (Proc *) NULL;
	char *pad, *lpad;

	int  tot_rec   = 0;		/* Total records found		*/
	int  tot_fail  = 0;		/* No. failed service calls	*/
	int  tot_nodata= 0;		/* No. of no-data results	*/
	int  tot_query = 0;		/* No. of queries		*/

	tot_query = (nservices * nobjects);/* Total No. queries made	*/

	for (svc=svcList; svc; svc=svc->next) {
	    tot_rec  += (svc->count > 0 ? svc->count : 0);
	    tot_fail += svc->nfailed;
	    tot_nodata += svc->nnodata;
	}

	pad = (nobjects == 1) ? "\t\t\t" : "\t\t\t\t\t";
	lpad = (nobjects == 1) ? "---------------" : "";
	printf ("\n");
	printf ("#%s-------------------------------------%s\n", pad, lpad);
/*
	printf ("#%s%4d    (Records Found)\n", pad, tot_rec);
	printf ("#%s%4d    (Resources Queried)\n", pad, tot_query);
	printf ("#%s%4d    (Failed Requests)\n", pad, tot_fail);
	printf ("#%s%4d    (Completed Requests)\n", pad, (tot_query-tot_fail));
	printf ("#%s\t  (%d Results w/ Data)\n", pad,
	    (tot_query - tot_fail - tot_nodata));
*/
	fprintf (stderr, "#%s%4d    (Records Found)\n", pad, tot_rec);
	fprintf (stderr, "#%s%4d    (Resources Queried)\n", pad, tot_query);
	fprintf (stderr, "#%s%4d    (Failed Requests)\n", pad, tot_fail);
	fprintf (stderr, "#%s%4d    (Completed Requests)\n", pad, 
	    (tot_query - tot_fail));
	fprintf (stderr, "#%s\t  (%d Results w/ Data)\n", pad,
	    (tot_query - tot_fail - tot_nodata));
	if (tot_nodata)
	    printf ("#%s\t  (%d Results w/ No Data)\n", pad, tot_nodata);
	printf ("#\n");

	if (verbose < 3)
	    return;

        svc  = svcList;
        for (t=0; t < nservices; t++, svc=svc->next) {
	    if (svc->nfailed || !FAILED_ONLY)
	        vot_printProcStat (svc->proc, svc->name, FAILED_ONLY);

            /* Free the proctable structure.
            */
            for (curproc=svc->proc; curproc; curproc=proc) {
	        proc = curproc->next;
                if (curproc) 
		    free ((void *) curproc);
            }
        }
    }
}


/************************************************************************
**  PRINTSVCLIST -- Debug routine to print the SvcList.
*/
void
vot_printSvcList (Service *sl)
{
    Service *s;
    Proc    *p;

    for (s=sl; s; s=s->next) {
	fprintf (stderr, "%15s:  nfail=%d  nrefs=%d  type=%d\ts=%ld\n",
	    s->name, s->nfailed, s->nrefs, s->type, (long)s);

        for (p=s->proc; p; p=p->next) {
	    fprintf (stderr, "\t\tpid=%d  status=%d  obj=%s\t    p=%ld\n",
		p->pid, p->status, p->obj->name, (long)p);
        }
    }
}


/************************************************************************
**  PROCOBJS --  Create threads to process the object list.  Our only 
**  argument is the Service object to run.
*/
void *
vot_procObjs (void *arg)
{
    int    nobj, nprocs, nrunning, nremaining, nupdate;
    int    lock,  nrep, status;
    pid_t  r_pid, pid;

    Object *obj    = objList;
    Service *svc   = (Service *)arg;
    Proc *curproc  = (Proc *) svc->proc;
    svcParams  pars;

		
    /* Figure out how many threads to run at a time.
    */
    nprocs = ( (nobjects > max_threads) ?  max_threads : nobjects );
    nupdate  = 10;

    nrep = nrunning = 0;
    nremaining = nobjects;

    for (nobj=1; nremaining > 0; ) {

	if (debug)
	    fprintf (stderr, "procObjs(%s): n=%d/%d nprocs=%d nrun=%d sr=%f\n",
    	  	svc->name, nobj, nobjects, nprocs, nrunning, sr);

        /* Spawn a process thread for each object/position.
        */
	if (nrunning < nprocs && nobj <= nobjects) {

	    /* Set up the service parameter struct.  Each thread gets its
	    ** own instance.
	    */
	    strcpy (pars.service_url, vizPatch(svc->service_url));
	    strcpy (pars.identifier, svc->identifier);
	    strcpy (pars.name, svc->name);
	    if (id_col && obj->id && obj->id[0])
	        strcpy (pars.oname, obj->id);
	    else
	        strcpy (pars.oname, obj->name);
	    strcpy (pars.title, svc->title);
	    pars.ra    = obj->ra;
	    pars.dec   = obj->dec;

	    /*  Prior to Registry 1.0 we didn't have a real cone capability
	    **  for Vizier tables and needed to set flags to download the
	    **  entire table.  This is no longer necessary, the user can set
	    **  a negative search radius to get the entire table if they choose.

	    pars.sr    = sr;
	    */
	    if (all_data && svc->type == SVC_VIZIER)
	 	pars.sr = -1.0;
	    else
		pars.sr = sr;
	    pars.fmt   = format;
	    pars.type  = svc->type;
	    pars.index = nobj;
	    pars.obj_index = nobj - 1;		/* zero-indexed		*/
	    pars.svc_index = svc->index;

	    if ((pid = (*(PFI)(*svc->func))((void *)&pars)) < 0) {
	        fprintf (stderr,"ERROR: process fork() fails\n");
	        pthread_exit ((void *) NULL);
	    }
	    nrunning++;
	    nobj++;

            /* Allocate the process summary struct.  Only save the status if
	    ** we'll be printing a summary later.
            */
    	    if ((extract & EX_COLLECT) || !quiet) {

		/* Lock the thread to protect us from messing with the
		** service list data.
		*/
	        lock = pthread_mutex_lock (&svc_mutex);
	        curproc->pid = pid;	    /* load the process struct	*/
	        curproc->obj = obj;
	        curproc->status = 0;
    		memset (curproc->root, 0, SZ_FNAME);
		if (use_name || all_named || id_col)
		    strcpy (curproc->root, vot_getOFName(&pars,NULL,(int)pid));
                else
		    strcpy (curproc->root, vot_getOFIndex(&pars,NULL,(int)pid));


	        curproc = curproc->next;    /* move on			*/
		lock = pthread_mutex_unlock (&svc_mutex);
	    }

	    if (debug)
		fprintf (stderr, "procObjs(%s): %d ra=%f dec=%f pid=%d\n",
    		    svc->name, nobj, obj->ra, obj->dec, pid);

	    if (obj) 
		obj = obj->next;
		
        } else {

            /* Process table full, wait for any child processes to complete.
            */
	    if (debug)
	        fprintf (stderr, "procObjs(%s:%d): waiting %d remaining....\n", 
    		    svc->name, getpid(), nremaining);

	    if ((r_pid = waitpid ((pid_t)-1, &status, (int) 0)) < 0 ) {
		/*  FIXME
		if (verbose || debug) 
	            fprintf (stderr, "ERROR: waitpid() fails, code[%d] %s\n",
		        (int)errno, strerror(errno));
	        pthread_exit ((void *) NULL);
		*/
	    }

	    status = WEXITSTATUS(status);
	    if (debug)
		fprintf (stderr, "pid = %d  stat = %d\n", r_pid, status);
		
	    lock = pthread_mutex_lock (&svc_mutex);
	    vot_setProcStat (svc, (int)r_pid, status);
	    lock = pthread_mutex_unlock (&svc_mutex);

	    nrunning--;
	    nremaining--;
        }

	if (!quiet && nobj < nobjects && (nobj % nupdate) == 0 && 
	    !count && !file_get && nrep == 0) {
	      fprintf (stderr,
		"# Service %15s: Completed %3d of %4d objects (%d running)\n",
    	        svc->name, nobj, nobjects, nrunning);
	    nrep = 1;
	} else if (nrep == 1) 
	    nrep = 0;
    }

    if (!quiet && !count && !file_get && !meta) {
	fprintf (stderr, "# Service %25s: ", svc->name);
	fprintf (stderr, "Finished processing (%d of %d succeeded).\n",
	    (nobjects - (svc->nfailed + svc->nnodata)), 
	    nobjects);
    }
    if (debug)  
	fprintf (stderr, "procObjs done (%s).\n", svc->name);


    pthread_exit (NULL);
}


static char *
vizPatch (char *url)
{
    static char new[SZ_LINE], *ip, *op;

    memset (new, 0, SZ_LINE);
    for (ip=url, op=new; *ip; ) {
	if (*ip == '&' && *(ip+1) == '/')
	   ip++;
	*op++ = *ip++;
    }

    return (new);
}


/************************************************************************
**  SETPROCSTAT -- Set the process return status.  'procList' is the 
**  process list running on this particular thread.
*/
static void
vot_setProcStat (Service *svc, int pid, int status)
{
    Service *s = svcList;
    Proc *pp;
    int    i, rc, sem_id, n = nservices;

    if (svcList == (Service *) NULL)
	return;

    for (s=svcList; s; s=s->next, n--) {
        for (pp=s->proc; pp; pp=pp->next) {
	    if (pp->pid == pid) {
		/* Set the status for this svc/obj process.
		*/
	        pp->status = status;
        	if (status == E_REQFAIL)
            	    s->nfailed++;
        	if (status == E_NODATA)
            	    s->nnodata++;

		/* If we created a URL extraction, add the URLS to the 
		** access list.
		*/
		if (extract == EX_ACREF || extract == EX_BOTH) {
		    char  fname[SZ_FNAME], url[SZ_URL];
		    FILE  *fd;
		    int   nf = 1;

		    /* Get the filename of the URLs we'll get.
		    */
		    memset (fname, 0, SZ_FNAME);
		    sprintf (fname, "%s.urls", pp->root);

		    /* Construct a template for each file.
		    */
		    if (access (fname, R_OK) == 0) {
			fd = fopen (fname, "r");
			for (i=1; fgets (url, SZ_URL, fd); i++) {
			    url[strlen(url)-1] = '\0';  /* kill newline   */
		    
			    memset (fname, 0, SZ_FNAME);
			    if (file_get > 1)
			        sprintf (fname, "%s.%03d", pp->root, i);
			    else
			        sprintf (fname, "%s", pp->root);

			    if (file_get && is_in_range(fileRange.ranges,i)) {
			        vot_addToAclist (url, fname);
			        nf++;
			    }
			}
			fclose (fd);
		    }
		}

		/* Get the semaphore set by the child indicating the
		** result count.
		*/
		sem_id = semget (pid, 0, 0);
		pp->count = semctl (sem_id, 0, GETVAL, 0);  /* get value  */
		s->count += pp->count;
    		rc = semctl (sem_id, 0, IPC_RMID, NULL);    /* release it */
        	if (status != E_NODATA && s->count == 0)
            	    s->nnodata++;

	        break;
	    }
        }
    }
    if (s == (Service *) NULL && n) {	/* no matching service found */
	fprintf (stderr, "Warning: NO SERVICE FOUND....pid=%d  status=%d\n",
	    pid, status);
	return;
    }
}



/************************************************************************
**  PRINTPROCSTAT -- Print a summary of the processing results.  If 
**  'failed_only' is set this is an error summary only.
*/
static void
vot_printProcStat (Proc *procList, char *svc_name, int failed_only)
{
    Proc *pp = procList;
    FILE *fd = (failed_only ? stderr : stdout);
    
    if (procList == (Proc *) NULL)
	return;

    fprintf (fd, "\nError Summary for '%s' :\n", svc_name);
    while (pp) {
	if (!failed_only || pp->status) {
	    fprintf (fd, "  Pid %6d: Source: %-12.12s (%.6f,%.6f)  %s\n",
		pp->pid,
		(pp->obj->name ? pp->obj->name : "(none)"), 
		pp->obj->ra, pp->obj->dec, vot_stat2code(pp->status));
	}
	pp = pp->next;
    }
}


/************************************************************************
**  STAT2CODE -- Convert an error code to a text string for printing.  
*/
static char *
vot_stat2code (int status)
{
    switch (status) {
    case E_NONE:	return ("OK");				break;
    case E_NODATA:	return ("No Data Returned");		break;
    case E_REQFAIL:	return ("Request Failed");		break;
    case E_FILOPEN:	return ("File Open Error");		break;
    case E_VOCINIT:	return ("VOClient init fails");		break;
    default:		return ("Unknown Error");		break;
    }

    return (NULL);
}


/************************************************************************
**  CNVTYPE -- Convert an error code to a text string for printing.  
static char *
vot_cnvType (char *intype)
{
    if (strcasecmp ("image", intype) == 0)
	return ("siap");
    else if (strcasecmp ("catalog", intype) == 0)
	return ("cone");
    else if (strcasecmp ("table", intype) == 0)
	return ("tabularskyservice");
    else 
	return (intype);
}
*/


/************************************************************************
**  PRINTPROCTIME -- Print a summary of the processing times.
*/
static void
vot_printProcTime ()
{
    if (!quiet) {
        int  r = ((int)re_time - (int)rs_time),
	     q = ((int)qe_time - (int)qs_time),
	     a = ((int)ae_time - (int)as_time);
        int  tot = (r + q + a);

        extern  char *toSexaTime (int n);


        printf ("#\n");
        printf ( "# Approx Time:  %02d:%02d:%02d\t",
	    (tot / 3600), (tot / 60), (tot % 60)); 
        printf ("(%02d:%02d Resolution, %02d:%02d Query, %02d:%02d Access)\n",
	    r / 60,  r % 60, 
	    q / 60,  q % 60, 
	    a / 60,  a % 60);
    }
}


/************************************************************************
**  USAGE --  Print a summary of the help options.
*/
static void
Usage()
{
  vot_printUsage();

  printf ("Where:\n");
  printf ("\n");
  printf ("    <resource>       ShortName/Identifier of data service \n");
  printf ("    <obj>            Name of object to be resolved\n");
  printf ("    <ra> <dec>       Decimal or Sexagesimal coords for query \n");
  printf ("    <url>            URL to access or ServiceURL to query \n");
  printf ("    <sr>             Search radius in degrees (def: 0.1) \n");
  printf ("\n");
  printf ("    These values may optionally be in a file containing them.\n");
  printf ("    Resource and object names may be comma-delimited lists\n");
  printf ("\n");
  printf ("\n");
  printf ("    -h               Print this help summary\n");
  printf ("    -v, --vverbose   Verbose or very-verbose mode\n");
  printf ("\n\tTask Behavior Flags:\n");
  printf ("    -a, --all        Query all data for the resource\n");
  printf ("    -c, --count      Print a count\n");
  printf ("    -g, --get <rng>  Get the files associated with a query\n");
  printf ("    -m, --meta       Print the column metadata for the resource\n");

  printf ("\n\tQuery Options:\n");
  printf ("    -b <bandpass>    Constrain by bandpass\n");
  printf ("    -i <file>        Take arguments from file (or stdin)\n");
  printf ("    -o <obj>         Specify object list\n");
  printf ("    -p <pos>         Specify position list\n");
  printf ("    -r               Set search radius\n");
  printf ("      -rs              Set radius in arc-seconds\n");
  printf ("      -rm              Set radius in arc-minutes\n");
  printf ("      -rd              Set radius in degrees (default: 0.1)\n");
  printf ("    -s <svc>         Specify the service name or url\n");
  printf ("    -t <type>        Constrain by service type\n");

  printf ("\n\tOutput Options:\n");
  printf ("    -A,--ascii       ASCII table output (.txt extension)\n");
  printf ("    -C,--csv         CSV table output (.csv extension)\n");
  printf ("    -H,--html        HTML table output (.html extension)\n");
#ifdef VO_INVENTORY
  printf ("    -I               Output results from the Inventory Service\n");
#endif
  printf ("    -K,--kml         KML output (.kml extension)\n");
  printf ("    -R,--raw         Raw (VOTable) output (.xml extension)\n");
  printf ("    -V,--votable     VOTable output (.xml extension)\n");
  printf ("    -T,--tsv         Tab-separated table output (.tsv extension)\n");
  printf ("    -O <root>	Set the root part of output name\n");
  printf ("\n");
  printf ("    -e,--extract     Extract results to separate file\n");
  printf ("      --ep             Extract only positions (to <file>.pos)\n");
  printf ("      --eu             Extract only access urls (to <file>.urls)\n");
  printf ("      --eh             Extract table to HTML (to <file>.html)\n");
  printf ("      --ek             Extract table to individual KML (to <file>.kml)\n");
  printf ("      --eK             Extract table to aggregate KML (to <file>.kml)\n");
  printf ("    -n,--nosave      No-save results, print a count only\n");
  printf ("    -q,--quiet       Suppress output to the screen\n");

  printf ("\n\tFormat-specific Options:\n");
  printf ("    --km <N>         Set max downloads (def: 100)\n");
  printf ("    --kgb            Group KML output by both object and service\n");
  printf ("    --kgo            Group KML output by object\n");
  printf ("    --kgs            Group KML output by service\n");
  printf ("    --ks <N>         Set result sample\n");
  printf ("    --kl             Disable Placemark labels\n");
  printf ("    --kr             Disable region box\n");
  printf ("    --kv             Disable verbose labels\n");
  printf ("\n");
  printf ("    --wb             Disable HTML table borders\n");
  printf ("    --wc             Disable HTML table verbose label\n");
  printf ("    --wh             Disable HTML page header\n");

  printf ("\n\tProcessing Options:\n");
  printf ("    --md <N>         Set max downloads (def: 1)\n");
  printf ("    --mp <N>         Set max number of processes per obj query\n");
  printf ("    --mt <N>         Set max number of resource threads to run\n");
  printf ("    \n");

  printf ("\n    Notes:\n");
  printf ("\t- Data Services may be listed by Registry ShortName of ");
  printf ("Identifier\n");
  printf ("\t- Sources may be object name, positions in decimal or sexages");
  printf ("imal\n\t  coords, or a file containing either.\n");

  printf ("\n\n");
  printf ("Resource Type Strings:\n");
  printf ("    catalog           Cone search services\n");
  printf ("    image             Simple Image Access services\n");
  printf ("    spectra           Simple Spectral Access services\n");
  printf ("    table             Vizier services\n");
  printf ("    <literal>         ResourceType from registry record\n");
  printf ("\n");
  printf ("Allowed Bandpass Strings:\n");
  printf ("    Radio             Millimeter           Infrared (IR)\n");
  printf ("    Optical           Ultraviolet (UV)     X-Ray (xray)\n");
  printf ("    Gamma-Ray (GR)\n");
  printf ("\n");

  printf ("\n\n");
  vot_printExamples();
  printf ("\n\n");
}


static void
vot_printExamples()
{

  printf ("Examples:\n---------\n\n");


  printf ("\
  1) Query the GSC 2.3 catalog for stars a) within the 0.1 degree \n\
     default search size around NGC 1234:  b) around all positions \n\
     contained in file 'pos.txt':  c) for the list of objects given \n\
     on the command line:  d) query a list of services for a list \n\
     of positions: e) print a count of results that would be returned\n\
     from 3 services for each position in a file:\n\
\n\
        %% vodata gsc2.3 ngc1234                 (a)\n\
        %% vodata gsc2.3 pos.txt                 (b)\n\
        %% vodata gsc2.3 m31,m51,m93             (c)\n\
        %% vodata svcs.txt pos.txt               (d)\n\
        %% vodata hst,chandra,gsc2.3 pos.txt     (e)\n\
\n\
  2) Find all images by HST of NGC 4258, create a KML file for Google Sky:\n\
\n\
        %% vodata -K -t image -all hst ngc4258\n\
\n\
  3) Query all (142) image services having data of the subdwarf\n\
     galaxy IC 10, print a count of the results only:\n\
\n\
        %% vodata -c -t image any IC10\n\
\n\
  4) Print a count of X-ray catalog data around Abell2712:\n\
\n\
        %% vodata -count -t catalog -b x-ray any abell2712\n\
\n\
  5) Print the column metadata returned by the RC3 catalog service:\n\
\n\
        %% vodata -meta -t catalog rc3\n\
\n\
  6) Use the Registry to query for resources using the search terms\n\
     'cooling flow'.  Upon examining the output the user notices a\n\
     Vizier paper titled 'Cooling Flows in 207 clusters of Galaxies'\n\
     that looks interesting.  Use the vodata task to download all\n\
     tables associated with this paper, save tables in the default\n\
     CSV format:\n\
\n\
        %% voregistry cooling flow\n\
        %% vodata -O white97 -all J/MNRAS/292/419\n\n\n\
  ");

}


static void
vot_printUsage()
{
  printf ("\n");
  printf ("Usage:\n");
  printf ("\n");
  printf ("    vodata <flags> [[ <resource> [<obj> | <ra> <dec>] [<sr>] | [<url>]]\n");
  printf ("\n");
}



/**
 *  Tests -- Task unit tests.
 */
static void
Tests (char *input)
{
    Task *task = &self;

    vo_taskTest (task, "--help", NULL);

    vo_taskTestFile ("m31\nm51\nm99\n", "pos.txt");
    vo_taskTestFile ("hst\nchandra\ngsc2.3\n", "svcs.txt");

    vo_taskTest (task, "gsc2.3", "ngc1234", NULL);
    vo_taskTest (task, "gsc2.3", "pos.txt", NULL);
    vo_taskTest (task, "gsc2.3", "m31,m51,m93", NULL);
    vo_taskTest (task, "svcs.txt", "pos.txt", NULL);
    vo_taskTest (task, "hst,chandra,gsc2.3", "pos.txt", NULL);

    vo_taskTest (task, "-c", "-t", "image", "any", "IC10", NULL);
    vo_taskTest (task, "--count", "--type=image", "any", "IC10", NULL);
    vo_taskTest (task, "-c", "-t", "catalog", "-b", "x-ray", 
	"any", "abell2712", NULL);
    vo_taskTest (task, "--count", "--type=image", "--bandpass=x-ray", 
	"any", "abell2712", NULL);

    vo_taskTest (task, "--meta", "rc3", NULL);

    vo_taskTest (task, "-O", "white97", "-all", "J/MNRAS/292/419", NULL);

    vo_taskTest (task, "-rv", "-t", "image", "xmm", NULL);
    vo_taskTest (task, "-cq", "xmm-newton", "3c273", NULL);
    vo_taskTest (task, "--count", "--quiet", "xmm-newton", "3c273", NULL);
    vo_taskTest (task, "--get", "xmm-newton", "3c273", NULL);

    vo_taskTest (task, "-e", "-O", "2mass", "-t", "image", "2mass", 
	"12:34:56.7", "-23:12:45.2", NULL);
    vo_taskTest (task, "-e", "--output=2mass", "--type=image", "2mass", 
	"12:34:56.7", "-23:12:45.2", NULL);

    vo_taskTest (task, "-e", "ivo://nasa.heasarc/abell", 
	"0.0", "0.0", "180.0", NULL);

    vo_taskTest (task, "-a", "galex", "m51", NULL);
    vo_taskTest (task, "--all", "galex", "m51", NULL);


    if (access ("pos.txt", F_OK) == 0)    unlink ("pos.txt");
    if (access ("svcs.txt", F_OK) == 0)   unlink ("svcs.txt");

    vo_taskTestReport (self);
}