aboutsummaryrefslogtreecommitdiff
path: root/vendor/voclient/voapps/lib/voUtil.c
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/voclient/voapps/lib/voUtil.c')
-rw-r--r--vendor/voclient/voapps/lib/voUtil.c2389
1 files changed, 2389 insertions, 0 deletions
diff --git a/vendor/voclient/voapps/lib/voUtil.c b/vendor/voclient/voapps/lib/voUtil.c
new file mode 100644
index 00000000..d367cf54
--- /dev/null
+++ b/vendor/voclient/voapps/lib/voUtil.c
@@ -0,0 +1,2389 @@
+/****************************************************************************
+** VOUTIL.C -- Utility procedures for the VO-CLI tasks.
+**
+** M. Fitzpatrick, NOAO, June 2007
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <string.h>
+#include <time.h>
+
+#include <curl/curl.h>
+#include <curl/types.h>
+#include <curl/easy.h>
+
+#include "VOClient.h"
+#include "votParse.h"
+#include "voAppsP.h"
+#include "voApps.h"
+
+
+#define SZ_RESBUF (256*256)
+#define SZ_QUERY 40960
+#define SZ_QSTRING 40960
+
+#define DEF_RESATTR "ServiceURL"
+#define MAX_ATTRS 32
+
+static int reg_nresolved = 0;
+
+
+extern int verbose, count, debug, errno, meta, res_all, quiet, do_votable;
+extern int group, nterms, table_hskip, ecols;
+extern char *terms[], *delim;
+
+
+int vot_regResolver (char *id, char *svctype, char *bpass, char *subject,
+ char *clevel, char *fields, int index, int exact,
+ int dalOnly, char **result);
+int vot_regSearch (char **ids, int nids, char *svctype, char *bpass,
+ char *subject, char *clevel, int orValues,
+ int votable, FILE *vot_fd,
+ int dalOnly, int sortRes, int terse);
+
+
+void pretty_print (char *result, int nresults);
+void pretty_print_table (char *result, int nresults, char *fields);
+void ppMultiLine (char *result, int poffset, int pwidth, int maxchars);
+void ppResSummary (char *result, int nresults);
+
+void vot_skipHdr (FILE *fd);
+char *vot_getTableCol (char *line, int col, int span);
+int vot_isNumericField (handle_t field);
+int vot_fileType (char *fname);
+
+char *vot_urlFname (char *url);
+void vot_printAttrs (char *fname, Query query, char *id);
+
+char *vot_parseSvcType (char *svctype, int exact);
+char *vot_parseBandpass (char *bpass);
+char *vot_parseSubject (char *subject);
+char *vot_parseCLevel (char *level);
+char *vot_mktemp (char *root);
+char *vot_copyStdin (void);
+
+/* Utility procedures.
+*/
+int isVOTable (char *fname);
+int isSexagesimal (char *str);
+int isDecimal (char *str);
+float sexa (char *s);
+char *toSexa (double pos);
+char *toSexaTime (int nsec);
+char *xmlEncode (char *in);
+
+int vot_atoi (char *val);
+long vot_atol (char *val);
+double vot_atof (char *val);
+
+void vot_setArg (char **argv, int *argc, char *value);
+void vot_printRegVOTableHdr (FILE *fd);
+void vot_printRegVOTableRec (FILE *fd, RegResult resource, int recnum);
+void vot_printRegVOTableTail (FILE *fd);
+
+extern char *strcasestr ();
+
+
+
+
+/****************************************************************************
+** Resolve a (presumed) ShortName or Identifier string to one or more
+** Registry resource attributes. By default we assume we are interested
+** only in the ServiceURL, however optional arguments allow us to narrow
+** the search to particular service types or individual records. Examples:
+**
+** 1) Find the ServiceURL for the GSC2.2 catalog
+**
+** cl> =regResolver ("GSC2.2")
+** http://chart.stsci.edu/GSCVO/GSC22VO.jsp?
+** cl> =nresolved()
+** 2 # found more than one resource
+**
+** 2) Print the Title and ServiceType for each record found for USNO-B1:
+**
+** cl> print (regResolver ("USNO-B1","","ServiceType,Title",-1))
+** CONE USNO-B1 Catalogue
+** SKYNODE USNO-B1 SkyNode from VizieR
+**
+** Note that in usage such as this we are still limited by the length
+** of output permitted by the print() function (currently 32*SZ_LINE).
+**
+** 3) Get the ServiceURL for the USNO-B1 Skynode service:
+**
+** cl> =regResolver ("USNO-B1","skynode")
+** http://cdsws.u-strasbg.fr/USNO-B1BasicSkyNode/services/BasicSkyNode
+**
+*/
+
+int
+vot_regResolver (char *term, char *svctype, char *bpass, char *subject,
+ char *clevel, char *fields, int index, int exact,
+ int dalOnly, char **res)
+{
+ int i, j, nreturns=0, nattrs=0, ret_attr_start=0, try_again=1;
+ int match=-1, istart, iend, recnum, alen, blen, bsize;
+ char *ip, *field_str = (char *)NULL;
+ char *attr_val=NULL, *attr_list[MAX_ATTRS], id[SZ_LINE];
+ char qstring[SZ_QSTRING], *svcstr, *bpstr, *substr, *conlev, *buf;
+ char attr_str[SZ_LINE], sbuf[SZ_RESBUF];
+ RegQuery query = 0;
+ RegResult resource = 0;
+
+
+ if (term[0]) {
+ bzero (id, SZ_LINE);
+ strcpy (id, term);
+ }
+ if (debug)
+ fprintf (stderr, "regResolver init: id='%s' type='%s'\n",
+ (id[0] ? id : "null"), (svctype ? svctype : "null"));
+
+ /* Sanity checks.
+ */
+ if (!id[0] && !svctype && !svctype[0]) {
+ fprintf (stderr, "regResolver(): Must specify 'id' or 'svctype'\n");
+ return (0);
+ }
+
+ bzero (qstring, SZ_QSTRING);
+ bzero (sbuf, SZ_RESBUF);
+ strcpy (attr_str, DEF_RESATTR);
+
+
+ /* Set the default attribute list we want from the query.
+ */
+ attr_list[0] = "ShortName";
+ attr_list[1] = "Identifier";
+ attr_list[2] = "Title";
+ attr_list[3] = "AccessUrl";
+ nattrs = 4;
+
+ /* Parse the fields argument if any.
+ */
+ if (fields && fields[0]) {
+ /* If we were given a list of fields, assume we want only those
+ ** and in that particular order.
+ */
+ ret_attr_start = nattrs;
+
+ /* Split up the input 'fields' string for use in the attr_list.
+ */
+ field_str = strdup (fields);
+ for (ip=field_str; *ip && nattrs < MAX_ATTRS; ) {
+ attr_list[nattrs++] = ip;
+ while (*ip && *ip != ',')
+ ip++;
+ if (*ip == ',')
+ *ip++ = '\0';
+ else
+ break;
+ }
+ } else
+ ret_attr_start = nattrs - 1; /* return ServiceURL only */
+
+
+ /* Now parse the service type and bandpass for extra constraints.
+ */
+ svcstr = vot_parseSvcType (svctype, !res_all);
+ bpstr = vot_parseBandpass (bpass);
+ substr = vot_parseSubject (subject);
+ conlev = vot_parseCLevel (clevel);
+
+ if (strcmp (id, "%") == 0) {
+ if (bpass || svctype || subject) {
+
+ /* Protect against a French overload.
+ */
+ if (!(subject || bpass) &&
+ (strcasestr(svctype,"table") ||
+ strcasestr(svctype,"tabular") ||
+ strcasestr(svctype,"vizier"))) {
+ fprintf (stderr, "Warning: Query too large to process.\n");
+ return (0);
+ }
+
+ bzero (qstring, SZ_QSTRING);
+ if (bpstr) { /* add bandpass constraint */
+ strcpy (qstring, bpstr);
+ }
+ if (svcstr) { /* add service constraint */
+ if (qstring[0])
+ strcat (qstring, " AND ");
+ strcat (qstring, svcstr);
+ }
+ if (substr) { /* add subject constraint */
+ if (qstring[0])
+ strcat (qstring, " AND ");
+ strcat (qstring, substr);
+ }
+ if (conlev) { /* add content constraint */
+ if (qstring[0])
+ strcat (qstring, " AND ");
+ strcat (qstring, conlev);
+ }
+
+ /* Execute the query. */
+ if (strcasestr (svcstr, "catalog"))
+ resource = voc_regSearch (qstring, "catalog", 0);
+ else
+ resource = voc_regSearch (qstring, NULL, 0);
+
+ } else {
+ fprintf (stderr, "Warning: Query too large to process.\n");
+ return (0);
+ }
+
+ } else {
+
+ /* Lastly, set the query string we'll be using.
+ */
+retry:
+ if (group) {
+ for (i=0; i < nterms; i++) {
+ strcat (qstring, terms[i]);
+ if (i < (nterms -1))
+ strcat (qstring, " OR ");
+ }
+ } else if (id[0]) {
+ char term[SZ_LINE], *ip, *op;
+
+ memset (term, 0, SZ_LINE);
+ for (ip=id, op=term; *ip && *ip != '#'; )
+ *op++ = *ip++;
+
+ if (exact) {
+ sprintf (qstring,
+ "((Identifier like '%s') OR (ShortName like '%s'))",
+ term, term);
+ } else {
+ sprintf (qstring,
+ "((Identifier like '%%%s%%') OR (ShortName like '%%%s%%'))",
+ term, term);
+ }
+ }
+
+ /* Do the registry query. Add the service-specific part of the query
+ ** once we get a handle.
+ */
+ query = voc_regQuery (qstring, 0);
+ if (bpass && bpass[0]) {
+ voc_regAddSearchTerm (query, bpstr, 0);
+ voc_regConstWaveband (query, bpass);
+ }
+ if (svctype && svctype[0]) {
+ voc_regAddSearchTerm (query, svcstr, 0);
+ voc_regConstSvcType (query, svctype);
+ }
+ if (substr && substr[0])
+ voc_regAddSearchTerm (query, substr, 0);
+ if (conlev && conlev[0])
+ voc_regAddSearchTerm (query, conlev, 0);
+ if (dalOnly)
+ voc_regDALOnly (query, dalOnly);
+
+ if (debug) {
+ printf ("regResolver: id='%s' type='%s' fields='%s' index=%d\n",
+ (id[0] ? id : "null"),
+ (svctype ? svctype : "null"),
+ (fields ? fields : "null"), index);
+ printf ("query string:\n\n%s\n\n", voc_regGetQueryString (query));
+ }
+
+ /* Execute the query.
+ */
+ resource = voc_regExecute (query);
+ }
+
+ blen = 0; /* length of result buffer used */
+
+ /* Save the number of resolved resources and get the requested attribute
+ * (or the default service URL).
+ */
+ reg_nresolved = voc_resGetCount (resource);
+ if (reg_nresolved > 0) {
+ int isVizier = 0;
+
+ bsize = (reg_nresolved * SZ_LINE); /* max size of result buffer */
+ buf = (char *) calloc (1, bsize);
+
+ if (do_votable) {
+ for (i=0; i < reg_nresolved; i++)
+ vot_printRegVOTableRec (stdout, resource, i);
+
+ return (reg_nresolved); /* return number of matches found */
+ }
+
+ nreturns = (index >= 0 ? 1 : reg_nresolved);
+
+ match = 0;
+ if (index >= 0 && reg_nresolved > 1) {
+ /* We didn't specify a record number but have more than one
+ * result. Look for an exact match in the ShortName or
+ * Identified which was a hidden part of the query.
+ */
+ for (i=0; i < reg_nresolved; i++) {
+ for (j=0; j < 2; j++) {
+ if ((attr_val = voc_resGetStr(resource, attr_list[j], i))) {
+ if (strncasecmp (id, attr_val, strlen(attr_val)) == 0) {
+ reg_nresolved = 1;
+ nreturns = 1;
+ match = i;
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ if (index >= 0) {
+ istart = index;
+ iend = index + 1;
+ reg_nresolved = 1;
+ } else if (match >= 0 && nreturns == 1) {
+ istart = match;
+ iend = match + 1;
+ reg_nresolved = 1;
+ } else {
+ istart = 0;
+ iend = nreturns;
+ }
+
+ /* For a negative index we list the attr for all records.
+ */
+ recnum = 0;
+ if (dalOnly)
+ reg_nresolved = 0;
+ for (i=istart; i < iend; i++) {
+ isVizier = 0;
+
+ if (dalOnly) {
+ int valid = 1;
+ for (j=ret_attr_start; j < nattrs; j++) {
+ if (strcmp (attr_list[j], "CapabilityStandardID") == 0) {
+ attr_val = voc_resGetStr (resource, attr_list[j], i);
+ if (attr_val) {
+ char *a = attr_val;
+ if (! (strncasecmp (a, "cone", 4) == 0 ||
+ strncasecmp (a, "sia", 3) == 0 ||
+ strncasecmp (a, "simpleimage", 10) == 0 ||
+ strncasecmp (a, "ssap", 4) == 0 ||
+ strncasecmp (a, "simplespec", 9) == 0)) {
+ valid = 0;
+ } else
+ reg_nresolved++;
+ }
+ break;
+ }
+ }
+ if (!valid)
+ continue;
+ }
+
+ for (j=ret_attr_start; j < nattrs; j++) {
+ attr_val = voc_resGetStr (resource, attr_list[j], i);
+ if (strncasecmp (attr_list[j], "identifier", 10) == 0)
+ isVizier = (attr_val && strcasestr (attr_val, "vizier"));
+ if (attr_val) {
+ alen = strlen (attr_val);
+ strcat (buf, attr_val);
+ if (j < (nattrs-1))
+ strcat (buf, "\t");
+ voc_freePointer ((char *) attr_val);
+ } else {
+ alen = 0;
+ strcat (buf, (isVizier ? "Catalog\t" : "INDEF\t"));
+ }
+
+ blen += max (alen, 10);
+ }
+ //if (nreturns > 1 && i < (reg_nresolved-1))
+ if (nreturns > 1)
+ strcat (buf, "\n");
+
+ recnum++;
+ }
+
+ attr_val = (char *) NULL;
+
+ } else {
+
+ if (try_again) {
+ if (strncasecmp("ivo://CDS.VizieR",id,16) == 0) {
+ char *ip, ivorn[SZ_LINE];
+ int len = strlen (id);
+
+ bzero (ivorn, SZ_LINE);
+ strcpy (ivorn, id);
+ for (ip = &ivorn[len-1]; *ip != '/'; ip--)
+ *ip = '\0';
+ *ip = '\0';
+
+ strcpy (id, ivorn);
+ try_again = 0;
+ goto retry;
+ }
+ }
+
+ buf = (char *) calloc (1, SZ_RESBUF);
+ for (j=0; j < nattrs; j++) {
+ strcpy (buf, "INDEF");
+ if (j < (nattrs-1))
+ strcat (buf, "\t");
+ }
+ }
+
+ if (field_str) free ((char *) field_str); /* free local memory */
+
+ /* Push the result operand on the return variable. We assume the result
+ ** is large enough for the value.
+ */
+ *res = buf;
+
+ if (bpstr) free (bpstr);
+ if (svcstr) free (svcstr);
+ if (substr) free (substr);
+
+ if (debug)
+ printf ("regResolver: reg_nresolved = %d\n", reg_nresolved);
+
+ return (reg_nresolved); /* return number of matches found */
+}
+
+
+/****************************************************************************
+** Search the registry for the given phrase and constraints.
+*/
+int
+vot_regSearch (char **ids, int nids, char *svctype, char *bpass,
+ char *subject, char *clevel, int orValues, int votable,
+ FILE *vot_fd, int dalOnly, int sortRes, int terse)
+{
+ int i, nresults=0, nattrs=0, keywOnly = 1, haveADQL;
+ char *attr_val=NULL, *attr_list[MAX_ATTRS];
+ char qstring[SZ_QUERY], keyws[SZ_RESBUF], *svcstr, *bpstr, *substr;
+ char term2[SZ_QUERY], *conlev;
+ char attr_str[SZ_LINE], *results, buf[SZ_LINE], cname[SZ_LINE];
+ RegResult res = 0;
+
+
+ strcpy (attr_str, DEF_RESATTR);
+
+ /* Set the default attribute list we want from the query.
+ */
+ attr_list[0] = "Title";
+ attr_list[1] = "CapabilityStandardID";
+ attr_list[2] = "ShortName";
+ attr_list[3] = "Subject";
+ attr_list[4] = "Identifier";
+ attr_list[5] = "ServiceUrl";
+ attr_list[6] = "Description";
+
+ switch (verbose) {
+ case 0: nattrs = 4; break;
+ case 1: nattrs = 5; break;
+ case 2: nattrs = 7; break;
+ }
+
+
+ /* Now parse the service type and bandpass for extra constraints.
+ */
+ svcstr = vot_parseSvcType (svctype, !res_all);
+ bpstr = vot_parseBandpass (bpass);
+ substr = vot_parseSubject (subject);
+ conlev = vot_parseCLevel (clevel);
+
+ /* Begin forming the SQL query term we'll use
+ */
+ bzero (qstring, SZ_QUERY);
+ bzero (term2, SZ_QUERY);
+ bzero (keyws, SZ_RESBUF);
+
+
+ /* Extract any terms that may be ADQL strings.
+ */
+ for (i=0; i < nids; i++) {
+ if (strcasestr (ids[i], "like") ||
+ strcasestr (ids[i], "<") ||
+ strcasestr (ids[i], ">") ||
+ strcasestr (ids[i], "=")) {
+ if (qstring[0] && orValues)
+ strcat (qstring, " OR ");
+ else if (qstring[0])
+ strcat (qstring, " AND ");
+ sprintf (buf, "(%s)", ids[i]);
+ strcat (qstring, buf);
+ keywOnly = 0;
+ haveADQL = 1;
+ }
+ }
+ for (i=1; i < nids; i++) {
+ strcat (term2, ids[i]);
+ if (i < (nids-1))
+ strcat (term2, " ");
+ }
+
+ if (nids == 0 || (nids == 1 && strcmp ("any", *ids) == 0)) {
+ strcpy (qstring, "(Identifier like '%')");
+ keywOnly = 0;
+ }
+
+
+ if (!keywOnly || nids == 0) {
+ if (svcstr) { /* add service constraint */
+ if (qstring[0]) {
+ sprintf (buf, "(%s) AND (%s)", qstring, svcstr);
+ strcpy (qstring, buf);
+ } else {
+ strcat (qstring, svcstr);
+ }
+ }
+ if (bpstr) { /* add bandpass constraint */
+ if (qstring[0]) {
+ sprintf (buf, "(%s) AND (%s)", qstring, bpstr);
+ strcpy (qstring, buf);
+ } else {
+ strcat (qstring, bpstr);
+ }
+ }
+ if (substr) { /* add subject constraint */
+ if (qstring[0]) {
+ sprintf (buf, "(%s) AND (%s)", qstring, substr);
+ strcpy (qstring, buf);
+ } else {
+ strcat (qstring, substr);
+ }
+ }
+ if (conlev) { /* add subject constraint */
+ if (qstring[0]) {
+ sprintf (buf, "(%s) AND (%s)", qstring, conlev);
+ strcpy (qstring, buf);
+ } else {
+ strcat (qstring, conlev);
+ }
+ }
+ }
+
+
+ /* Build a string arrays of the keyword terms.
+ */
+ if (ids[0] && keywOnly) {
+ RegQuery query = (RegQuery) 0;
+
+ if (nids == 0 || (nids == 1 && strcmp ("any", *ids) == 0)) {
+ strcpy (qstring, "(Identifier like '%')");
+ query = voc_regQuery (qstring, FALSE); /* get a query object */
+
+ } else {
+ for (i=0; i < nids; i++) {
+ if (keyws[0])
+ strcat (keyws, " ");
+ if (!strcasestr (ids[i], "like") &&
+ !strcasestr (ids[i], "<") &&
+ !strcasestr (ids[i], ">") &&
+ !strcasestr (ids[i], "="))
+ strcat (keyws, ids[i]);
+ }
+ query = voc_regQuery (keyws, orValues); /* get a query object */
+ }
+
+#ifdef USE_CONSTRAINTS
+ if (svctype) /* set constraints */
+ voc_regConstSvcType (query, svctype);
+ if (bpass)
+ voc_regConstWaveband (query, bpass);
+#else
+ if (svcstr && svcstr[0])
+ voc_regAddSearchTerm (query, svcstr, 0);
+ if (bpstr && bpstr[0])
+ voc_regAddSearchTerm (query, bpstr, 0);
+#endif
+
+ if (substr && substr[0])
+ voc_regAddSearchTerm (query, substr, 0);
+ if (conlev && conlev[0])
+ voc_regAddSearchTerm (query, conlev, 0);
+ if (dalOnly)
+ voc_regDALOnly (query, dalOnly);
+ voc_regSortRes (query, sortRes);
+
+ res = voc_regExecute (query); /* execute it */
+
+ } else {
+/*
+ res = voc_regSearch (qstring, NULL, orValues);
+*/
+ res = voc_regSearch (qstring, term2, orValues);
+ bzero (keyws, SZ_RESBUF);
+ }
+ nresults = voc_resGetCount (res);
+
+
+ /* If no response, see if it was a ShortName used as a keyword term...
+ */
+ if (nresults == 0 && !(svcstr || bpstr || substr || conlev) && !haveADQL) {
+ bzero (qstring, SZ_QUERY);
+ if (ids[0]) {
+ for (i=0; i < nids; i++) {
+ if (qstring[0])
+ strcat (qstring, " OR ");
+ if (!strcasestr (ids[i], "like") &&
+ !strcasestr (ids[i], "<") &&
+ !strcasestr (ids[i], ">") &&
+ !strcasestr (ids[i], "=")) {
+ sprintf (buf,
+ "(ShortName like '%s') OR (Identifier like '%s')",
+ ids[i], ids[i]);
+ strcat (qstring, buf);
+ }
+ }
+ }
+
+ res = voc_regSearch (qstring, (nids ? keyws : NULL), 1);
+
+ nresults = voc_resGetCount (res);
+ if (nresults && !count) {
+ verbose = 2;
+ } else if (nresults == 0) {
+ res = voc_regSearch (qstring, NULL, orValues);
+ nresults = voc_resGetCount (res);
+ }
+ }
+
+ if (debug)
+ printf ("regSearch: qstr='%s' keyws='%s' nres = %d\n",
+ qstring, keyws, nresults);
+
+
+ /* No longer need the query buffers so free them here.
+ */
+ if (svcstr) free (svcstr);
+ if (bpstr) free (bpstr);
+ if (substr) free (substr);
+
+
+ /* Return the result count if that's all we wanted.
+ */
+ if (count) {
+ results = (char *)calloc (1, (nresults * 30));
+ strcpy (results, " \t");
+ for (i=0; i < nresults; i++) {
+ attr_val = voc_resGetStr (res, attr_list[1], i); /* SvcType */
+ strcat (results, (attr_val ? attr_val : " "));
+ strcat (results, "\t \n\t");
+ voc_freePointer ((char *) attr_val);
+ }
+ if (keyws[0])
+ printf ("%-20s %3d\t", keyws, nresults);
+ else
+ printf ("%d ", nresults);
+ if (verbose && !bpstr)
+ ppResSummary (results, nresults);
+ printf ("\n");
+
+ free ((char *) results);
+ return (nresults);
+ }
+
+
+ if (votable) {
+ for (i=0; i < nresults; i++) {
+ vot_printRegVOTableRec (vot_fd, res, i);
+ }
+ return (nresults); /* return number of matches found */
+ }
+
+ /* Print out the results for each resource based on the verbosity
+ ** level.
+ **
+ ** Title: <title> ServiceType: <type> verb = 0
+ ** ShortName: <name> Subject: <id> verb = 0
+ ** Identifier: <id> ServiceURL: <url> verb = 1
+ ** Description: <descr> verb = 2
+ **
+ */
+ for (i=0; i < nresults; i++) {
+
+ if (i > 0 && !terse)
+ printf ("-----------------------------------------------\n");
+
+ if (dalOnly) { /* CapName */
+ attr_val = voc_resGetStr (res, "CapabilityName", i);
+ bzero (cname, SZ_LINE);
+ strcpy (cname, (attr_val ? attr_val : ""));
+ voc_freePointer ((char *) attr_val);
+ }
+
+ if (terse) {
+ /*
+ int idx = voc_resGetInt (res, "index", i),
+ rank = voc_resGetInt (res, "rank", i);
+
+ printf ("%2d(%2d) ", rank, idx);
+ */
+ if (sortRes)
+ printf ("%3d %3d ", i, voc_resGetInt(res, "index", i) );
+
+ if (terse > 1) {
+ /* "Tweet" format.
+ */
+ char *ip;
+
+ printf ("New VO Resource: ");
+
+ attr_val = voc_resGetStr (res, "Title", i);
+ printf ("\"%-s\" ", attr_val);
+ voc_freePointer ((char *) attr_val);
+
+ attr_val = voc_resGetStr (res, "Waveband", i);
+ printf ("W:%s ", attr_val);
+ voc_freePointer ((char *) attr_val);
+
+ attr_val = voc_resGetStr (res, "CapabilityStandardID", i);
+ printf ("T:%s ", attr_val);
+ voc_freePointer ((char *) attr_val);
+
+ attr_val = voc_resGetStr (res, "Subject", i);
+ if (attr_val && (ip = strchr (attr_val, (int)':')))
+ *ip = '\0'; /* kill qualifiers */
+ printf ("S:%-s\n", attr_val);
+ voc_freePointer ((char *) attr_val);
+
+ } else {
+ attr_val = voc_resGetStr (res, attr_list[1], i);/* SvcType */
+ printf ("%-7.7s ", attr_val);
+ voc_freePointer ((char *) attr_val);
+
+ attr_val = voc_resGetStr (res, attr_list[0], i);/* Title */
+ printf ((sortRes ? "%-63.63s\n" : "%-71.71s\n"), attr_val);
+ voc_freePointer ((char *) attr_val);
+ }
+
+ continue;
+
+ } else {
+ attr_val = voc_resGetStr (res, attr_list[1], i); /* SvcType */
+ printf (" Type: %-s\n", attr_val);
+ voc_freePointer ((char *) attr_val);
+
+ attr_val = voc_resGetStr (res, attr_list[0], i); /* Title */
+ printf (" Title: ");
+ ppMultiLine (attr_val, 13, 67, 1024);
+ printf ("\n");
+ voc_freePointer ((char *) attr_val);
+ }
+
+ attr_val = voc_resGetStr (res, attr_list[2], i); /* ShortName */
+ if (dalOnly && verbose == 0) {
+ printf (" ShortName: %-s\n", attr_val);
+ printf ("ServiceName: %s\n", cname);
+ } else
+ printf (" ShortName: %-s\n", attr_val);
+ voc_freePointer ((char *) attr_val);
+
+ attr_val = voc_resGetStr (res, attr_list[3], i); /* Subject */
+ printf (" Subject: ");
+ ppMultiLine (attr_val, 13, 67, 1024);
+ printf ("\n");
+ voc_freePointer ((char *) attr_val);
+
+ if (verbose == 0)
+ continue;
+
+ attr_val = voc_resGetStr (res, attr_list[4], i); /* Identifier */
+ if (dalOnly)
+ printf (" Identifier: %-s#%s\n", attr_val, cname);
+ else
+ printf (" Identifier: %-s\n", attr_val);
+ voc_freePointer ((char *) attr_val);
+
+ attr_val = voc_resGetStr (res, attr_list[5], i); /* ServiceUrl */
+ printf (" ServiceURL: %-s\n", attr_val);
+ voc_freePointer ((char *) attr_val);
+
+ if (verbose == 1)
+ continue;
+
+ attr_val = voc_resGetStr (res, attr_list[6], i); /* Descr. */
+ printf ("Description: ");
+ ppMultiLine (attr_val, 13, 67, 1024);
+ printf ("\n");
+ voc_freePointer ((char *) attr_val);
+ }
+
+ return (nresults); /* return number of matches found */
+}
+
+
+/************************************************************************
+** PRETTY_PRINT -- Pretty-print a table for verbose resolution output.
+*/
+void
+pretty_print (char *result, int nresults)
+{
+ int i, j, ncols, col;
+ char *ip, value[SZ_RESULT];
+
+
+ /* pretty-print the table using the defined widths.
+ */
+ if (verbose) {
+ ip = result;
+ ncols = 3;
+ for (i=0; i < nresults; i++) {
+ j = 0;
+ for (col=0; col < ncols; ) {
+ bzero (value, SZ_RESULT);
+ while (*ip && (*ip != '\t' && *ip != '\n'))
+ value[j++] = *ip++;
+
+ if (col == (ncols-1)) {
+ ppMultiLine (value, PP_OFFSET, PP_WIDTH, PP_MAXCHARS);
+ break;
+ } else
+ printf ("%-20s", value);
+
+ j = 0;
+ col++;
+ ip++;
+ }
+ printf ("\n");
+ ip++;
+ }
+ } else {
+ printf ("%s\n", result);
+ return;
+ }
+
+}
+
+
+/************************************************************************
+** PPRESSUMMARY -- Print a summary of the resources found. Assumes the
+** ServiceType is the second column of the result string.
+*/
+
+void
+ppResSummary (char *result, int nresults)
+{
+ register int i, j;
+ int Ni = 0, /* image count */
+ Nc = 0, /* catalog count */
+ Nt = 0, /* table count */
+ Ns = 0, /* spectra count */
+ Nsn = 0, /* SkyNode count */
+ Nother = 0; /* 'other' count */
+ char *ip, value[SZ_RESULT];
+
+
+ if (nresults == 0 || verbose == 1)
+ return;
+
+ ip = result;
+ for (i=0; i < nresults; i++) {
+ bzero (value, SZ_RESULT);
+ while (*ip != '\t') ip++; /* skip first column */
+ for (++ip, j=0; *ip != '\t';) /* gather the value */
+ value[j++] = tolower (*ip++);
+ while (*ip && *ip != '\n') ip++; /* skip last column */
+ ip++;
+
+ if (strstr (value, "siap"))
+ Ni++;
+ else if (strstr (value, "cone"))
+ Nc++;
+ else if (strstr (value, "tabular"))
+ Nt++;
+ else if (strstr (value, "ssap"))
+ Ns++;
+ else if (strstr (value, "skynode") || strstr (value, "skyservice"))
+ Nsn++;
+ else
+ Nother++;
+ }
+
+ printf ("(");
+ if (Nc) printf ("Cat: %-2d ", Nc);
+ if (Nt) printf ("Tab: %-2d ", Nt);
+ if (Ni) printf ("Img: %-2d ", Ni);
+ if (Ns) printf ("Spec: %-2d ", Ns);
+ if (Nsn) printf ("SNode: %-2d ", Nsn);
+ if (Nother) printf ("Other: %-2d", Nother);
+ printf (")");
+}
+
+
+
+/************************************************************************
+** PPMULTILINE -- Print a lengthy string on multiple lines. Used to print
+** the last column of a table where we indent the carried-over lines to the
+** specified offset. No effort is made to break lines at a 'nice' spot
+** since long URLs and such won't fit anyway, so we just cut the line and
+** continue.
+*/
+
+void
+ppMultiLine (char *result, int poffset, int pwidth, int maxchars)
+{
+ register int i, j, ellipses = 0;
+ int len = strlen((result ? result : ""));
+ char *ip;
+ extern int longlines;
+
+ if (result)
+ len = strlen (result);
+ else
+ return;
+
+
+ for (i=0; i < len-1; i++ ) {
+ if (result[i] == '\n' && result[i+1] != '\n')
+ result[i] = ' ';
+ }
+
+ ip = &result[len-1]; /* strip trailing w/s */
+ while ((isspace(*ip) || *ip == '\n') && ip > result)
+ *ip-- = '\0';
+
+ if (longlines) {
+ printf ("%s", result);
+ return;
+ }
+
+ if (len > maxchars) {
+ result[maxchars] = '\0';
+ len = maxchars;
+ ellipses++;
+ }
+
+ if (len < pwidth) {
+ for (ip=result; *ip && isspace(*ip); )
+ ip++;
+ printf ("%s", ip);
+ } else {
+ j = pwidth;
+ for (i=0; i < len; ) {
+ while (isspace (result[i])) i++;
+
+ printf ("%-*.*s\n", pwidth, pwidth, &result[i]);
+ i = j + 1;
+ j += pwidth;
+ printf ("%*s", poffset, " ");
+ if (j > len) {
+ while (isspace (result[i])) i++;
+ printf ("%s", &result[i]);
+ if (ellipses)
+ printf (" (read more)....");
+ break;
+ }
+ }
+ }
+}
+
+
+/************************************************************************
+** PRETTY_PRINT_TABLE -- Pretty-print a table with computed column widths.
+*/
+void
+pretty_print_table (char *result, int nresults, char *fields)
+{
+ int i, j, w, ncols, col, width[256];
+ char *ip, value[SZ_RESULT];
+
+
+ if (!result)
+ return;
+ if (!verbose && !fields) {
+ printf ("%s\n", result);
+ return;
+ }
+
+
+ /* Figure out how many columns there are.
+ */
+ for (ip=result, ncols=1; *ip && *ip != '\n'; ip++) {/* do only 1st line */
+ if (*ip && *ip == '\t')
+ ncols++;
+ }
+
+ /* Calculate the column widths needed to align the columns.
+ */
+ bzero (width, 256 * sizeof(int));
+ ip = result;
+ for (i=0; i < nresults; i++) {
+ for (w=0, col=0; *ip; ) {
+ if (*ip == '\t' || *ip == '\n') {
+ if (w >= width[col])
+ width[col] = w + 3;
+ w = 0;
+ col++;
+ } else
+ w++;
+ if (*ip++ == '\n')
+ break;
+ }
+ }
+
+
+ /* Now print the table using the computed widths.
+ */
+ ip = result;
+ for (i=0; i < nresults; i++) {
+ j = 0;
+ bzero (value, SZ_RESULT);
+ for (col=0; col < ncols; ) {
+ if (!*ip || (*ip == '\t' || *ip == '\n')) {
+ value[j++] = '\0';
+ if (col == (ncols-1))
+ printf ("%-s", value);
+ else
+ printf ("%-*s", width[col], value);
+ j = 0;
+ col++;
+ } else
+ value[j++] = *ip;
+ if (*ip && *ip == '\n')
+ break;
+ ip++;
+ }
+ printf ("\n");
+ ip++;
+ }
+}
+
+
+
+/****************************************************************************
+** VOT_PARSESVCTYPE -- Parse the service type specification. Allow for
+** synonyms like 'catalog' for 'cone', 'image' for 'siap', etc.
+*/
+char *
+vot_parseSvcType (char *svctype, int exact)
+{
+ char *ip, *op, val[SZ_FNAME], buf[SZ_FNAME];
+ char *svcstr = NULL, *like = NULL;
+ int not = 0, more = 0;
+
+
+ like = (exact ? "" : "%"); /* initialize */
+
+ if (svctype && svctype[0]) {
+ svcstr = calloc (1, 4*SZ_LINE);
+
+ strcat (svcstr, "(");
+ for (ip=svctype; *ip; ) {
+ more = 0; /* re-initialize */
+ not = 0;
+ bzero (val, SZ_FNAME);
+
+ for (op=val; *ip; ) {
+ if (*ip == '-') {
+ not++, ip++;
+ } else if (*ip == ',') {
+ more++, ip++;
+ break;
+ } else
+ *op++ = *ip++;
+ }
+
+ /* Aliases for service type include:
+ **
+ ** Cone -> catalog
+ ** SIAP -> image
+ ** TABULARSKYSERVICE -> table
+ ** SSAP -> spectrum
+ ** TAP -> query
+ */
+ if (not) strcat (svcstr, "(!");
+
+ if (strncasecmp (val,"catalog",3) == 0)
+ strcat (svcstr, "(Tag like '%catalog%')");
+ else if (strncasecmp (val,"image",5) == 0)
+ strcat (svcstr, "(Tag like '%image%')");
+ else if (strncasecmp (val,"spectr",6) == 0)
+ strcat (svcstr, "(Tag like '%spec%')");
+ else if (strncasecmp (val,"table",5) == 0)
+ strcat (svcstr, "(Identifier like '%Vizier%')");
+ else {
+ bzero (buf, SZ_FNAME);
+ sprintf (buf, "(Tag like '%s%s%s')", like, val, like);
+ strcat (svcstr, buf);
+ }
+
+ if (not) strcat (svcstr, ")");
+ if (more) strcat (svcstr, " OR ");
+ }
+ strcat (svcstr, ")");
+
+ return (svcstr);
+ }
+
+ return ((char *)NULL);
+}
+
+
+
+/****************************************************************************
+** VOT_PARSEBANDPASS -- Convert a bandpass specification to an ADQL query. We
+** map things like 'x-ray' and 'xray' here to expand the query on behalf of
+** the user.
+**
+** Permitted values include:
+** "Radio", "Millimeter", "Infrared" (IR), "Optical", "Ultraviolet" (UV),
+** "X-Ray" (XRay), and "Gamma-Ray" (GR).
+*/
+char *
+vot_parseBandpass (char *bpass)
+{
+ char *ip, *op, val[SZ_FNAME], buf[SZ_FNAME];
+ char *bpstr = NULL;
+ int not = 0, more = 0;
+
+
+ if (bpass && bpass[0]) {
+ bpstr = calloc (1, 6*SZ_LINE);
+
+ strcat (bpstr, "(");
+ for (ip=bpass; *ip; ) {
+ more = 0; /* re-initialize */
+ not = 0;
+ bzero (val, SZ_FNAME);
+
+ for (op=val; *ip; ) {
+ if (*ip == '-' && strncasecmp(ip,"-ray",4)) {
+ not++, ip++;
+ } else if (*ip == ',') {
+ more++, ip++;
+ break;
+ } else
+ *op++ = *ip++;
+ }
+
+ if (not) strcat (bpstr, "(!");
+
+ if (strncasecmp (val, "radio",3) == 0)
+ strcat (bpstr, "([coverage/waveband] like '%radio%')");
+ else if (strncasecmp (val,"millimeter",9) == 0)
+ strcat (bpstr, "([coverage/waveband] like '%millimeter%')");
+ else if (strncasecmp (val,"infrared",5) == 0 ||
+ strncasecmp (val,"ir",2) == 0)
+ strcat (bpstr, "([coverage/waveband] like '%infrared%')");
+ else if (strncasecmp (val,"optical",8) == 0)
+ strcat (bpstr, "([coverage/waveband] like '%optical%')");
+ else if (strncasecmp (val,"ultraviolet",5) == 0 ||
+ strncasecmp (val,"uv",2) == 0)
+ strcat (bpstr,"([coverage/waveband] like '%ultraviolet%')");
+ else if (strncasecmp (val,"x-ray",5) == 0 ||
+ strncasecmp (val,"xray",4) == 0)
+ strcat (bpstr, "([coverage/waveband] like '%x-ray%')");
+ else if (strncasecmp (val,"gamma-ray",9) == 0 ||
+ strncasecmp (val,"gammaray",8) == 0)
+ strcat (bpstr, "([coverage/waveband] like '%gamma-ray%')");
+ else {
+ bzero (buf, SZ_FNAME);
+ sprintf (buf, "([coverage/waveband] like '%%%s%%')", val);
+ strcat (bpstr, buf);
+ }
+
+ if (not) strcat (bpstr, ")");
+ if (more) strcat (bpstr, " OR ");
+ }
+ strcat (bpstr, ")");
+
+ return (bpstr);
+ }
+
+ return ((char *)NULL);
+}
+
+
+/****************************************************************************
+** VOT_PARSESUBJECT -- Convert a subject specification to an ADQL query
+** string. We don't impose a vocabulary on the allowed Subject string, but
+** do allow the string to be a comma-delimited list of subjects.
+*/
+char *
+vot_parseSubject (char *subject)
+{
+ char *ip, *op, val[SZ_FNAME], buf[SZ_FNAME];
+ char *substr;
+ int more = 0;
+
+
+ substr = calloc (1, 6*SZ_LINE);
+ if (subject && subject[0]) {
+ strcat (substr, "(");
+ for (ip=subject; *ip; ) {
+ more = 0; /* re-initialize */
+ bzero (val, SZ_FNAME);
+
+ for (op=val; *ip; ) {
+ if (*ip == ',') {
+ more++, ip++;
+ break;
+ } else
+ *op++ = *ip++;
+ }
+
+ bzero (buf, SZ_FNAME);
+ sprintf (buf, "([content/subject] like '%%%s%%')", val);
+ strcat (substr, buf);
+
+ if (more) strcat (substr, " OR ");
+ }
+ strcat (substr, ")");
+
+ return (substr);
+ }
+
+ return ((char *)NULL);
+}
+
+
+/****************************************************************************
+** VOT_PARSECLEVEL -- Convert a ContentLevel specification to an ADQL query
+** string.
+*/
+char *
+vot_parseCLevel (char *level)
+{
+ char *ip, *op, *str, val[SZ_FNAME], buf[SZ_FNAME];
+ int more = 0;
+
+ str = calloc (1, 6*SZ_LINE);
+ if (level && level[0]) {
+ strcat (str, "(");
+ for (ip=level; *ip; ) {
+ more = 0; /* re-initialize */
+ memset (val, 0, SZ_FNAME);
+
+ for (op=val; *ip; ) {
+ if (*ip == ',') {
+ more++, ip++;
+ break;
+ } else
+ *op++ = *ip++;
+ }
+
+ memset (buf, 0, SZ_FNAME);
+ sprintf (buf, "([content/contentLevel] like '%%%s%%')", val);
+ strcat (str, buf);
+ if (more)
+ strcat (str, " OR ");
+ }
+ strcat (str, ")");
+ return (str);
+ }
+
+ return ((char *)NULL);
+}
+
+
+/************************************************************************
+** Return the filename part of a URL.
+*/
+char *
+vot_urlFname (char *url)
+{
+ char *ip;
+ int len = strlen (url);
+
+ for (ip=&url[len-1]; ip >= url; ip--) {
+ if (*ip == '&' || *ip == '?')
+ *ip = '\0';
+ if (*ip == '/')
+ return (ip+1);
+ }
+
+ return (ip);
+}
+
+
+/******************************************************************************
+** Print the resource attributes.
+*/
+void
+vot_printAttrs (char *fname, Query query, char *ident)
+{
+ char *result = (char *) NULL, *qstring = (char *) NULL;
+ int i=0, nrec, nattr;
+#ifdef OLD_ATTRS
+ char *ip, *attrList = (char *) NULL;
+ QRecord rec = (QRecord) NULL; /* Query record */
+ QResponse qr = (QResponse) NULL; /* Query response */
+#else
+ int vot = 0, nbytes = 0;
+ FILE *fd = stdout;
+ char *ip, *op;
+#endif
+
+
+
+ if (!query) {
+ fprintf (stderr, "# Query failed, returning\n");
+ return;
+ }
+
+#ifdef OLD_ATTRS
+ if ((qr = voc_executeQuery (query))) {
+ rec = voc_getRecord (qr, 0); /* get a row in the table */
+ nrec = voc_getRecordCount (qr);
+ }
+ nattr = (rec ? voc_getAttrCount (rec) : 0);
+
+ if (nattr > 0) {
+ printf ("\n# --- Identifier: %s\n#\n", ident);
+
+ if (!meta)
+ printf ("# returns %d records containing %d attributes each\n",
+ nrec, nattr);
+
+ attrList = voc_getAttrList (rec);
+ printf ("# Col UCD\n");
+ printf ("# --- ---\n# %2d ", (i=1));
+ for (i++, ip=attrList; *ip; ip++) {
+ if (isspace (*ip))
+ printf ("\n# %2d ", i++);
+ else
+ putchar (*ip);
+ }
+ printf ("\n#\n");
+
+ if (attrList) free ((void *) attrList);
+ } else
+ printf ("# --- No Attributes Found ---\n#\n");
+
+#else
+
+ if (query > 0) {
+ if (! (qstring = voc_getQueryString (query, DAL_CONN, 0)))
+ return;
+ } else
+ return;
+
+ while (isspace (*qstring))
+ qstring++;
+
+ if ((ip = strcasestr (qstring, "format=image"))) {
+ op = ip;
+ while (*ip && *ip != '&')
+ ip++;
+ if (*ip) {
+ for (ip++; *ip ;)
+ *op++ = *ip++;
+ }
+ *op = '\0';
+ }
+
+ if ((result = voc_getRawURL (qstring, &nbytes)) == NULL)
+ return;
+
+ /* FIXME -- rawURL still returns garbage at the end.....
+ result[nbytes] = '\0';
+ */
+
+ if ( nbytes > 0 && (vot = vot_openVOTABLE (result)) > 0 ) {
+
+ char ucd[SZ_FNAME], name[SZ_FNAME], desc[SZ_LINE], id[SZ_FNAME], *at;
+ extern char *vot_getFieldName(), *vot_getFieldDesc();
+ extern char *vot_getFieldUCD(), *vot_getFieldID();;
+
+ handle_t res, tab, data, tdata, field, handle;
+
+
+ res = vot_getRESOURCE (vot); /* get handles */
+ if ((tab = vot_getTABLE (res)) <= 0) {
+ if ((data = vot_getDATA (tab)) <= 0) {
+ if ((tdata = vot_getTABLEDATA (data))) {
+ nrec = vot_getNRows (tdata);
+ nattr = vot_getNCols (tdata);
+ }
+ }
+ }
+
+
+ if (!fname || strcmp (fname, "-") == 0) {
+ fd = stdout;
+ } else {
+ if ((fd = fopen (fname, "w+")) == (FILE *) NULL)
+ return ;
+ }
+
+ fprintf (fd, "\n Service: %s\n NAttrs: %d\n\n",
+ (ident ? ident : "N/A"), nattr);
+ fprintf (fd,
+ " Col UCD Name Description\n");
+ fprintf (fd,
+ " --- --- ---- -----------------------\n");
+
+ for (i=1, field=vot_getFIELD (tab); field; field=vot_getNext (field)) {
+
+ fprintf (fd, " %3d ", i++);
+
+ memset (ucd, 0, SZ_FNAME);
+ memset (name, 0, SZ_FNAME);
+ memset (id, 0, SZ_FNAME);
+ memset (desc, 0, SZ_LINE);
+
+ strcpy (ucd, ((at=vot_getAttr (field, "ucd")) ? at : ""));
+ strcpy (name, ((at=vot_getAttr (field, "name")) ? at : ""));
+ strcpy (id, ((at=vot_getAttr (field, "id")) ? at : ""));
+
+ if ((handle = vot_getDESCRIPTION (field)))
+ strcpy (desc, vot_getValue (handle));
+ else
+ strcpy (desc, " ");
+
+/*
+ strcpy (desc, ((at=vot_getAttr (field, "description")) ? at : ""));
+
+ fprintf (fd, "%-27.27s ", (ucd[0] ? ucd :
+ (name[0] ? name :
+ (id[0] ? id : " "))) );
+*/
+ fprintf (fd, "%-16.16s %-10.10s ", ucd, name);
+
+ if (desc[0]) {
+ ppMultiLine (desc, 34, 45, 1024);
+ } else {
+ if (name[0] && strcmp (name, id) == 0)
+ fprintf (fd, "name=id='%s'", name);
+ else {
+ if (name[0])
+ fprintf (fd, "name='%s'%s", name, (id[0] ? ", ":" "));
+ if (id[0])
+ fprintf (fd, "id='%s'", id);
+ }
+ }
+
+
+ fprintf (fd, "\n");
+ }
+ vot_closeVOTABLE (vot);
+
+ if (fd != stdout)
+ fclose (fd);
+
+ } else if (!quiet)
+ fprintf (stderr, " %-50s Error\n", ident);
+
+
+/* FIXME -- causes a segfault
+ if (result)
+ voc_freePointer ((char *) result);
+*/
+#endif
+}
+
+
+/**
+ * VOT_SETARG -- Set a value in an argv vector, update the count.
+ */
+void
+vot_setArg (char **argv, int *argc, char *value)
+{
+ int i = *argc;
+
+ argv[i] = strdup (value);
+ *argc += 1;
+}
+
+
+/************************************************************************
+** PRINTVOTABLEHDR -- Print the prolog to the VOTable output.
+*/
+void
+vot_printRegVOTableHdr (FILE *fd)
+{
+fprintf (fd, "\
+<?xml version=\"1.0\" encoding=\"utf-8\"?>\
+<VOTABLE ID=\"ID\" xmlns=\"http://www.ivoa.net/xml/VOTable/v1.1\">\
+<DESCRIPTION>REGISTRY SEARCH RESULTS</DESCRIPTION>\
+<RESOURCE>\
+<INFO name=\"QUERY_STATUS\" value=\"OK\"></INFO>\
+<TABLE>");
+
+if (verbose == 0) {
+
+fprintf (fd, "\
+<FIELD datatype=\"char\" name=\"title\" arraysize=\"*\"/>\
+<FIELD datatype=\"char\" name=\"shortName\" arraysize=\"*\"/>\
+<FIELD datatype=\"char\" name=\"identifier\" arraysize=\"*\"/>\
+<FIELD datatype=\"char\" name=\"accessURL\" arraysize=\"*\"/>\
+<FIELD datatype=\"char\" name=\"referenceURL\" arraysize=\"*\"/>\
+<FIELD datatype=\"char\" name=\"capabilityClass\" arraysize=\"*\"/>\
+<FIELD datatype=\"char\" name=\"contentLevel\" arraysize=\"*\"/>\
+<FIELD datatype=\"char\" name=\"type\" arraysize=\"*\"/>\
+<FIELD datatype=\"char\" name=\"waveband\" arraysize=\"*\"/>\
+<FIELD datatype=\"char\" name=\"publisher\" arraysize=\"*\"/>\
+<FIELD datatype=\"char\" name=\"subject\" arraysize=\"*\"/>\
+<FIELD datatype=\"char\" name=\"version\" arraysize=\"*\"/>");
+
+} else {
+
+fprintf (fd, "\
+<FIELD ID=\"tags\" datatype=\"char\" name=\"categories\" arraysize=\"*\"/>\
+<FIELD ID=\"shortName\" datatype=\"char\" name=\"shortName\" arraysize=\"*\"/>\
+<FIELD ID=\"title\" datatype=\"char\" name=\"title\" arraysize=\"*\"/>\
+<FIELD ID=\"description\" datatype=\"char\" name=\"description\" arraysize=\"*\"/>\
+<FIELD ID=\"publisher\" datatype=\"char\" name=\"publisher\" arraysize=\"*\"/>\
+<FIELD ID=\"waveband\" datatype=\"char\" name=\"waveband\" arraysize=\"*\"/>\
+<FIELD ID=\"identifier\" datatype=\"char\" name=\"identifier\" ucd=\"ID_MAIN\" arraysize=\"*\"/>\
+<FIELD ID=\"updated\" datatype=\"char\" name=\"descriptionUpdated\" arraysize=\"*\"/>\
+<FIELD ID=\"subject\" datatype=\"char\" name=\"subject\" arraysize=\"*\"/>\
+<FIELD ID=\"type\" datatype=\"char\" name=\"type\" arraysize=\"*\"/>\
+<FIELD ID=\"contentLevel\" datatype=\"char\" name=\"contentLevel\" arraysize=\"*\"/>\
+<FIELD ID=\"regionOfRegard\" unit=\"arcsec\" datatype=\"int\" name=\"typicalRegionSize\"/>\
+<FIELD ID=\"version\" datatype=\"char\" name=\"version\" arraysize=\"*\"/>\
+<FIELD ID=\"capabilityClass\" datatype=\"char\" name=\"capabilityClass\" arraysize=\"*\"/>\
+<FIELD ID=\"capabilityID\" datatype=\"char\" name=\"capabilityStandardID\" arraysize=\"*\"/>\
+<FIELD ID=\"capabilityValidationLevel\" datatype=\"char\" name=\"capabilityValidationLevel\" arraysize=\"*\"/>\
+<FIELD ID=\"interfaceClass\" datatype=\"char\" name=\"interfaceClass\" arraysize=\"*\"/>\
+<FIELD ID=\"interfaceVersion\" datatype=\"char\" name=\"interfaceVersion\" arraysize=\"*\"/>\
+<FIELD ID=\"interfaceRole\" datatype=\"char\" name=\"interfaceRole\" arraysize=\"*\"/>\
+<FIELD ID=\"accessURL\" datatype=\"char\" name=\"accessURL\" arraysize=\"*\"/>\
+<FIELD ID=\"supportedInputParam\" datatype=\"char\" name=\"supportedInputParam\" arraysize=\"*\"/>\
+<FIELD ID=\"maxRadius\" datatype=\"int\" name=\"maxSearchRadius\"/>\
+<FIELD ID=\"maxRecords\" datatype=\"int\" name=\"maxRecords\"/>\
+<FIELD ID=\"publisherID\" datatype=\"char\" name=\"publisherIdentifier\" arraysize=\"*\"/>\
+<FIELD ID=\"referenceURL\" datatype=\"char\" name=\"referenceURL\" arraysize=\"*\"/>");
+}
+fprintf (fd, "<DATA><TABLEDATA>");
+
+fflush (fd);
+}
+
+
+/************************************************************************
+** PRINTVOTABLEREC -- Print an individual record in the search results
+** as a VOTable row.
+*/
+void
+vot_printRegVOTableRec (FILE *fd, RegResult resource, int recnum)
+{
+ register int i;
+ char *attr_val, *fmt, *attr;
+
+ static char *resAttr[] = {
+ "Title", "ShortName", "Identifier",
+ "AccessURL", "ReferenceURL", "CapabilityClass",
+ "ContentLevel", "Type", "Waveband",
+ "Creator", "Subject", "Version",
+ NULL
+ };
+
+ static char *resAttrVerbose[] = {
+ "tags", "shortName", "title",
+ "description", "publisher", "waveband",
+ "identifier", "updated", "subject",
+ "type", "contentLevel", "regionOfRegard",
+ "version", "capabilityClass", "capabilityID",
+ "capabilityValidationLevel", "interfaceClass",
+ "interfaceVersion", "interfaceRole", "accessURL",
+ "supportedInputParam", "maxRadius", "maxRecords",
+ "publisherID", "referenceURL",
+ NULL
+ };
+
+
+
+ fprintf (fd, "<TR>");
+ for (i=0; 1; i++) {
+ attr = (verbose ? resAttrVerbose[i] : resAttr[i]);
+ if (attr == NULL)
+ break;
+
+ attr_val = xmlEncode (voc_resGetStr (resource, attr, recnum));
+
+ /* Escape any URLs to take care of special chars.
+ */
+ fmt = (*attr_val && strstr(attr,"URL") ?
+ "<TD><![CDATA[%s]]></TD>" : "<TD>%s</TD>");
+
+ if (!(*attr_val) &&
+ (strcmp (attr, "regionOfRegard") == 0 ||
+ strcmp (attr, "maxRadius") == 0 ||
+ strcmp (attr, "maxRecords") == 0)) {
+ fprintf (fd, fmt, "0");
+
+ } else if (attr_val && *attr_val) {
+ fprintf (fd, fmt, attr_val);
+
+ } else
+ fprintf (fd, "<TD/>");
+
+ if (attr_val)
+ voc_freePointer ((char *) attr_val);
+ }
+ fprintf (fd, "</TR>");
+ fflush (fd);
+}
+
+
+
+/************************************************************************
+** PRINTVOTABLETAIL -- Print the epilog to the VOTable output.
+*/
+void
+vot_printRegVOTableTail (FILE *fd)
+{
+fprintf (fd, "\
+</TABLEDATA>\
+</DATA>\
+</TABLE>\
+</RESOURCE>\
+</VOTABLE>\n");
+}
+
+
+
+/****************************************************************************
+** Lexical utility procedures.
+*/
+
+char *
+xmlEncode (char *in)
+{
+ char *ip, *op, *out;
+
+ if (in == (char *) NULL)
+ return (calloc(1,2)); /* caller will free this pointer */
+
+ out = calloc (1, strlen(in) * 2);
+ ip = in;
+ op = out;
+
+ while (*ip) {
+ if (*ip == '<') {
+ strncpy (op, "&gt;", 4);
+ op += 4;
+ } else if (*ip == '>') {
+ strncpy (op, "&gt;", 4);
+ op += 4;
+ } else if (*ip == '&') {
+ strncpy (op, "&amp;", 5);
+ op += 5;
+ } else if (*ip == '\'') {
+ strncpy (op, "&quot;", 6);
+ op += 6;
+ } else if (*ip == '\"') {
+ strncpy (op, "&dquot;", 7);
+ op += 7;
+ } else
+ *op++ = *ip;
+
+ ip++;
+ }
+
+
+ if (in)
+ voc_freePointer ((char *) in);
+
+ return (out);
+}
+
+
+
+/************************************************************************
+** VOT_GETLINE -- Get the next line in a file/stdin. We use this procedure
+** to allow for parsing input that may be piped in where newlines are
+** expressed as the string "\n".
+*/
+char *
+vot_getline (FILE *fd)
+{
+ int i, ch, peek;
+ static char cmdline[SZ_LINE];
+
+
+ bzero (cmdline, SZ_LINE);
+
+ for (i=ch=0; ch != EOF; i++) {
+ cmdline[i] = ch = (char) fgetc (fd);
+ if (i == 0 && ch == EOF)
+ return (NULL);
+ else if (i > 0 && (ch == EOF || ch == '\n')) {
+ cmdline[i] = '\0';
+ break;
+ } else if (ch == (int) '\\') {
+ if ((peek = fgetc (fd)) == (int)'n') {
+ cmdline[i] = '\0';
+ break;
+ } else
+ ungetc (peek, fd);
+ }
+ }
+
+ return (cmdline);
+}
+
+
+/****************************************************************************
+** NORMALIZECOORD -- Normalize a coordinate string, i.e. strip whitespace
+** from the ends and replace internal whitespace with a ':' in the case of
+** sexagesimal values.
+*/
+char *
+vot_normalizeCoord (char *coord)
+{
+ static char *ip, *op, norm[SZ_LINE];
+
+
+ bzero (norm, SZ_LINE);
+
+ /* Remove trailing whitespace */
+ for (ip=&coord[strlen(coord)-1]; isspace(*ip) && ip > coord; )
+ *ip = '\0';
+
+ /* Skip leading whitespace */
+ for (ip=coord; *ip && isspace(*ip); ip++)
+ ;
+
+ for (op=norm; *ip; ) {
+ if (isspace (*ip)) {
+ *op++ = ':';
+ while (*ip && isspace(*ip)) /* collapse multiple space */
+ ip++;
+ } else
+ *op++ = *ip++;
+ }
+
+ return (norm);
+}
+
+
+/****************************************************************************
+** Normalize the names, i.e. replace anything other than [.+-] with '-'.
+*/
+char *
+vot_normalize (char *str)
+{
+ char *ip, *op;
+ static char name[SZ_FNAME];
+
+ if (str == (char *)NULL)
+ return ("");
+
+ bzero (name, SZ_FNAME);
+ for (ip=str, op=name; *ip; ) {
+ if (strchr (".+-", (int)*ip))
+ *op++ = *ip++;
+ else if (!isalnum ((int)*ip))
+ *op++ = '-', ip++;
+ else
+ *op++ = *ip++;
+ }
+
+ return (name);
+}
+
+
+
+/* UTILITY FUNCTIONS.
+*/
+
+/****************************************************************************
+** ISVOTABLE -- Test a file or string to see if it's a VOTable.
+*/
+int
+isVOTable (char *fname)
+{
+ int i;
+ FILE *fd = (FILE *) NULL;
+ char line[SZ_LINE];
+
+ if (fname[0] == '-') {
+ (void) fgets (line, SZ_LINE, stdin);
+ if (line[0] == '<')
+ return (1);
+
+ } else if (access (fname, R_OK) == 0) {
+
+ /* Process the file contents.
+ */
+ if ((fd = fopen (fname, "r")) == (FILE *) NULL) {
+ fprintf (stderr, "ERROR: Cannot open file '%s'\n", fname);
+ return (0);
+ }
+
+ for (i=0; i < 10 && fgets (line, SZ_LINE, fd); i++) {
+ if (strcasestr (line, "VOTABLE")) {
+ fclose (fd);
+ return (1);
+ }
+ }
+
+ if (fd)
+ fclose (fd);
+ }
+
+ return (0);
+}
+
+
+int
+isSexagesimal (char *str)
+{
+ register int i;
+
+ /* Allow only numbers, colons, decimal point, whitespace, and sign. */
+ for (i=(strlen(str)-1); i >= 0; i--)
+ if (!isdigit(str[i]) && strchr("/:+- .\t,", (int)str[i])==(char *)NULL)
+ return (0);
+
+ return (1);
+}
+
+int
+isDecimal (char *str)
+{
+ register int i;
+
+ /* Allow only numbers, decimal point, whitespace, and sign. */
+ for (i=(strlen(str)-1); i >= 0; i--)
+ if (!isdigit(str[i]) && strchr("/+- .\t,", (int)str[i])==(char *)NULL)
+ return (0);
+
+ return (1);
+}
+
+float
+sexa (char *s)
+{
+ int n, sign;
+ int hr, minutes;
+ float sec, val;
+ extern double atof();
+
+ while (isspace (*s)) /* skip leading whitespace */
+ s++;
+ sign = (*s == '-') ? (s++, -1) : 1; /* get the sign */
+
+ minutes = 0;
+ sec = 0.;
+ n = sscanf (s, "%d:%d:%f", &hr, &minutes, &sec);
+ if (n < 1 || minutes < 0 || sec < 0)
+ val = -999.0;
+ else
+ /* Beware: Evaluation here can produce roundoff errors!
+ */
+ val = sign * (hr + ((float)minutes)/60. + sec/3600.);
+
+ return (val);
+}
+
+
+char *
+toSexa (double pos)
+{
+ static char str[SZ_LINE];
+ int d, m;
+ float s, frac;
+ char sign = (pos < 0.0 ? '-' : 0);
+
+
+ pos = (pos < 0.0 ? -pos : pos);
+
+ d = (int) pos;
+ frac = (pos - d);
+ m = frac * 60.0;
+ s = ((frac * 60.0) - m) * 60.0;
+
+ if (sign)
+ sprintf (str, "%c%02d:%02d:%04.1f", sign, d, m, s);
+ else
+ sprintf (str, "%02d:%02d:%04.1f", d, m, s);
+
+ return (str);
+}
+
+
+char *
+toSexaTime (int nsec)
+{
+ char tstr[SZ_LINE];
+ int m, s;
+
+ m = nsec / 60;
+ s = nsec % 60;
+
+ sprintf (tstr, "%02d:%02d", m, s);
+
+ return (strdup (tstr)); /* note potential memory leak! */
+}
+
+
+char *
+vot_mktemp (char *root)
+{
+ char *tmp;
+ static char tmpfile[SZ_LINE];
+ char *tmpdir = "/tmp";
+
+
+ /* Get a temporary file name based on the pid.
+ */
+ bzero (tmpfile, SZ_LINE);
+ if ((tmp = getenv ("TMP")) != NULL)
+ tmpdir = tmp;
+ sprintf (tmpfile, "%s/%s%d", tmpdir, root, (int)(getpid()+time((time_t)0)));
+
+ return (tmpfile);
+}
+
+
+/* Copy the standard input to a temp file we can parse more easily.
+*/
+char *
+vot_copyStdin ()
+{
+ static char *line, tmpfile[SZ_FNAME];
+ FILE *fd;
+ extern char *vot_getline();
+
+
+ /* Open a temp file and copy the stdin to it.
+ */
+ strcpy (tmpfile, vot_mktemp ("vodo"));
+ if ((fd = fopen (tmpfile, "w+")) == (FILE *) NULL) {
+ fprintf (stderr, "Error opening tmp file '%s'\n", tmpfile);
+ return ((char *)NULL);
+ }
+
+ while ( (line = vot_getline (stdin)) )
+ fprintf (fd, "%s\n", line);
+ fclose (fd);
+
+ return (tmpfile);
+}
+
+
+/* Skip header lines of a table.
+*/
+void
+vot_skipHdr (FILE *fd)
+{
+ register int i;
+ char line[SZ_LINE];
+
+
+ if (fd && table_hskip) { /* Skip header lines */
+ rewind (fd);
+ for (i=0; i < table_hskip; i++) {
+ if (fgets (line, SZ_LINE, fd) == NULL) {
+ break;
+ }
+ }
+ }
+}
+
+
+
+/****************************************************************************
+** GETTABLECOL -- Get the requested column value from the table line.
+** Column numbers are assumed to be one-indexed.
+*/
+char *
+vot_getTableCol (char *line, int col, int span)
+{
+ int i, nsp = span;
+ char sep[6], *ip, *op, *del = (char *)NULL;
+ static char value[SZ_LINE];
+
+
+ bzero (value, SZ_LINE);
+ bzero (sep, 6);
+
+ /* If we're doing exact columns, copy whatever is in those columns
+ ** to the output file. Otherwise, parse the line based on delimiters.
+ */
+ if (ecols) {
+ strncpy (value, (char *)&line[col-1], span);
+ for (i=span-1; i && isspace(value[i]); i--) /* trailing space */
+ value[i] = '\0';
+ for (i=0; isspace(value[i]); i++) /* leading space */
+ ;
+ return (&value[i]);
+ }
+
+ if ((del = strpbrk(line, " \t,|;"))) /* get delimiter */
+ sep[0] = del[0];
+ else
+ strcpy (sep, delim);
+
+ op = value;
+ for (i=1, ip=line; *ip; ip++) {
+ if (strchr (sep, (int)*ip) || *ip == '\n') {
+ if (sep[0] == ' ') {
+ while ( *ip == sep[0] ) /* skip multiple spaces */
+ ip++;
+ if (*ip != '\n')
+ ip--; /* reposition for next */
+ }
+ if (i++ == col) {
+ if (--nsp == 0) {
+ return (value);
+ } else {
+ *op++ = ' '; /* add a space for span */
+ i--;
+ }
+ } else
+ bzero ((op=value), SZ_LINE);
+ } else
+ *op++ = *ip;
+ }
+
+ return ( (i == col) ? value : (char *)NULL );
+}
+
+
+/**
+ * VOT_ISNUMERICFIELD -- Determine if a <FIELD> is a numeric datatype.
+ */
+int
+vot_isNumericField (handle_t field)
+{
+ char *dtype = vot_getAttr (field, "datatype");
+ char *asize = vot_getAttr (field, "arraysize");
+
+
+ if (asize && asize[0]) {
+ return (0);
+
+ } else {
+ if ((strncasecmp (dtype, "floatComplex", 12) == 0) ||
+ (strncasecmp (dtype, "doubleComplex", 13) == 0))
+ return (0);
+
+ if ((strncasecmp (dtype, "short", 5) == 0) ||
+ (strncasecmp (dtype, "int", 3) == 0) ||
+ (strncasecmp (dtype, "long", 4) == 0) ||
+ (strncasecmp (dtype, "float", 5) == 0) ||
+ (strncasecmp (dtype, "double", 6) == 0))
+ return (1);
+ }
+ return (0);
+}
+
+
+/**
+ * VOT_FILETYPE -- Determine what type of file we have.
+ */
+int
+vot_fileType (char *fname)
+{
+ FILE *fd = (FILE *) NULL;
+ char buf[1024];
+ int nread, ftype = -1;
+
+ if ((fd = fopen (fname, "r")) != NULL) {
+ memset (buf, 0, 1024);
+ nread = fread (buf, 1023, 1, fd);
+ if (strncasecmp ("SIMPLE", buf, 6) == 0) {
+ /* FIXME -- Need to add spectrum serialization. */
+ ftype = VOT_FITS;
+ } else if (strcasestr (buf, "VOTABLE")) {
+ /* FIXME -- Need to add spectrum serialization. */
+ ftype = VOT_VOTABLE;
+ }
+ fclose (fd);
+ } else
+ fprintf (stderr, "fileType: cannot open '%s'\n", fname);
+
+ return (ftype);
+}
+
+
+/**
+ * VOT_SUM32 -- Internet checksum, 32 bit unsigned integer version.
+ */
+int
+vot_sum32 (char *str)
+{
+ register int i;
+ unsigned int *iarray;
+ unsigned long lsum = 0;
+ int sum = 0;
+ int len, carry=0, newcarry=0;
+
+ iarray = (unsigned int *) str;
+ len = strlen (str) / 4;
+
+ for (i=0; i<len; i++) {
+ if (iarray[i] > ~ lsum)
+ carry++;
+ lsum += iarray[i];
+ }
+
+ while (carry) {
+ if (carry > ~ lsum)
+ newcarry++;
+ lsum += carry;
+ carry = newcarry;
+ newcarry = 0;
+ }
+
+ return (abs(sum = lsum));
+}
+
+
+/**
+ * STRDIC -- Search a dictionary string for a match with an input string.
+ * The input string may be an abbreviation of a dictionary entry, however,
+ * it is an error if the abbreviation is not unique. The entries in the
+ * dictionary string are separated by a delimiter character which is the
+ * first character of the dictionary string. The full name of the matched
+ * dictionary entry found is returned in out_str; the function value is
+ * the word index of the dictionary entry. The output string may be the
+ * same as the input string.
+ */
+
+#include <ctype.h>
+
+int strdic (
+ char *in_str, /* Input string, always lower case */
+ char *out_str, /* Output string as found in dictionary */
+ int maxchars, /* Maximum length of output string */
+ char *dict /* Dictionary string */
+)
+{
+ char ch, fch;
+ int start, len, ip, i, match, entry;
+
+
+ if (dict == NULL || dict[0] == '\0')
+ return (0);
+
+ for (i=0; isspace(in_str[i]); i++)
+ ;
+
+ start = i;
+ match = -1;
+ ip = 1;
+ len = strlen (&in_str[start]);
+ fch = in_str[start];
+
+
+ /* Search the dictionary string. If the input string matches a
+ * dictionary entry it is either an exact match (len = dictionary
+ * entry length) or a legal abbreviation. If an abbreviation
+ * matches two entries it is ambiguous and an error.
+ */
+ for (entry=0; dict[ip] != '\0'; entry=entry+1) {
+ if (dict[ip] == fch) {
+ if (strncmp (&dict[ip], &in_str[start], len) == 0) {
+ for (i=0; i < maxchars; i++) {
+ ch = dict[ip+i-1];
+ if ((ch == dict[0]) || (ch == '\0'))
+ break;
+ out_str[i] = ch;
+ }
+ out_str[i] = '\0';
+
+ if ((dict[ip+len] == dict[0]) || (dict[ip+len] == '\0'))
+ return (entry); /* exact match */
+ else {
+ /* If we already have a match and the new match is not
+ * exact, then the abbreviation is ambiguous.
+ */
+ if (match != 0)
+ return (0);
+ else
+ match = entry;
+ }
+ }
+ }
+
+ do {
+ ip = ip + 1;
+ } while (dict[ip-1] != dict[0] && dict[ip] != '\0');
+ }
+
+ if (match <= 0)
+ strcpy (out_str, in_str);
+ return (match);
+}
+
+
+/*****************************************************************************
+****** URL String Encode / Decode ******
+*****************************************************************************/
+
+/* Converts a hex character to its integer value */
+static char from_hex (char ch)
+{
+ return (isdigit(ch) ? ch - '0' : tolower(ch) - 'a' + 10);
+}
+
+/* Converts an integer value to its hex character*/
+static char to_hex (char code)
+{
+ static char hex[] = "0123456789abcdef";
+ return (hex[code & 15]);
+}
+
+
+/**
+ * VO_URLENCODE -- Returns a url-encoded version of str. Call must free()
+ * the pointer that is returned.
+ */
+char *
+vo_urlEncode (char *str)
+{
+ char *pstr = str, *buf = malloc(strlen(str) * 3 + 1), *pbuf = buf;
+
+ while (*pstr) {
+ if (isalnum(*pstr) ||
+ *pstr == '-' ||
+ *pstr == '_' ||
+ *pstr == '.' ||
+ *pstr == '~')
+ *pbuf++ = *pstr;
+ else if (*pstr == ' ')
+ *pbuf++ = '+';
+ else {
+ *pbuf++ = '%';
+ *pbuf++ = to_hex (*pstr >> 4);
+ *pbuf++ = to_hex (*pstr & 15);
+ }
+ pstr++;
+ }
+ *pbuf = '\0';
+ return buf;
+}
+
+
+/**
+ * VO_URLDECODE -- Returns a url-decoded version of str. Call must free()
+ * the pointer that is returned.
+ */
+char *
+vo_urlDecode (char *str)
+{
+ char *pstr = str, *buf = malloc(strlen(str) + 1), *pbuf = buf;
+
+ while (*pstr) {
+ if (*pstr == '%') {
+ if (pstr[1] && pstr[2]) {
+ *pbuf++ = from_hex(pstr[1]) << 4 | from_hex(pstr[2]);
+ pstr += 2;
+ }
+ } else if (*pstr == '+') {
+ *pbuf++ = ' ';
+ } else {
+ *pbuf++ = *pstr;
+ }
+ pstr++;
+ }
+ *pbuf = '\0';
+
+ return buf;
+}
+
+
+/**
+ * VOT_TOURL -- Convert a filename to a URL.
+ */
+char *
+vot_toURL (char *arg)
+{
+ /* If we have an existing protocol simply return the argument.
+ */
+ if ((strncmp (arg, "http:", 5) == 0) ||
+ (strncmp (arg, "file:", 5) == 0) ||
+ (strncmp (arg, "ftp:", 4) == 0))
+ return (arg);
+
+ if (access (arg, F_OK) == 0) {
+ char cwd[SZ_LINE];
+ static char buf[SZ_LINE];
+
+ memset (cwd, 0, SZ_LINE);
+ getcwd (cwd, (unsigned long) SZ_LINE);
+
+ memset (buf, 0, SZ_LINE);
+ if (arg[0] == '/')
+ sprintf (buf, "file://%s", arg);
+ else
+ sprintf (buf, "file://%s/%s", cwd, arg);
+
+ return (buf);
+ }
+
+ return (arg);
+}
+
+
+/**
+ * VOT_ISVALIDFORMAT -- Check whether we have a supported format request.
+ */
+int
+vot_isValidFormat (char *fmt)
+{
+ char format[SZ_LINE];
+ extern int strdic ();
+
+ return ( (strdic (fmt, format, SZ_FORMAT, FORMATS) >= 0) );
+}
+
+
+/**
+ * VOT_ATOI -- System atoi() with lexical argument checking.
+ */
+int
+vot_atoi (char *val)
+{
+ char *ip;
+
+ for (ip = val; *ip; ip++) {
+ if (isalpha ((int) *ip)) {
+ fprintf (stderr, "Warning: value '%s' is not an integer\n", val);
+ break;
+ }
+ }
+ return (atoi (val));
+}
+
+
+/**
+ * VOT_ATOL -- System atol() with lexical argument checking.
+ */
+long
+vot_atol (char *val)
+{
+ char *ip;
+
+ for (ip = val; *ip; ip++) {
+ if (isalpha ((int) *ip) && *ip != '-' && *ip != '+') {
+ fprintf (stderr, "Warning: value '%s' is not an integer\n", val);
+ break;
+ }
+ }
+ return (atol (val));
+}
+
+
+/**
+ * VOT_ATOF -- System atoi() with lexical argument checking.
+ */
+double
+vot_atof (char *val)
+{
+ char *ip, c;
+
+ for (ip = val; *ip; ip++) {
+ c = *ip;
+ if (! (tolower(c) == 'e' || tolower(c) == 'd' || isspace(c) ||
+ (c == '-' || c == '+' || c == '.') || isdigit(c))) {
+ fprintf (stderr,
+ "Warning: value '%s' is not a floating point value\n", val);
+ break;
+ }
+ }
+ return (atof (val));
+}
generated by cgit (git 2.34.1) at 2025-09-20 18:30:09 -0400