aboutsummaryrefslogtreecommitdiff
path: root/pkg/vocl/sampFuncs.c
diff options
context:
space:
mode:
Diffstat (limited to 'pkg/vocl/sampFuncs.c')
-rw-r--r--pkg/vocl/sampFuncs.c1186
1 files changed, 1186 insertions, 0 deletions
diff --git a/pkg/vocl/sampFuncs.c b/pkg/vocl/sampFuncs.c
new file mode 100644
index 00000000..0823d5d0
--- /dev/null
+++ b/pkg/vocl/sampFuncs.c
@@ -0,0 +1,1186 @@
+/* Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+ */
+
+/**
+ * SAMP.C -- Interface routines for the client and server side of the
+ * SAMP messaging commands.
+ */
+
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <readline/readline.h> /* to install rl_event_hook */
+
+#define import_spp
+#define import_libc
+#define import_stdio
+#define import_prstat
+#define import_xwhen
+#include <iraf.h>
+
+#include "config.h" /* CL declarations */
+#include "clmodes.h"
+#include "operand.h"
+#include "mem.h"
+#include "grammar.h"
+#include "opcodes.h"
+#include "param.h"
+#include "task.h"
+#include "errs.h"
+#include "clsamp.h"
+
+
+extern pid_t cl_pid;
+extern int samp_registered;
+extern char samp_cmd[SZ_CMDBLK];
+
+extern int optbl[];
+extern char *ifnames[];
+
+extern Handler userHandlers[];
+extern int numHandlers;
+
+extern XINT samp; /* SAMP handle */
+extern pthread_mutex_t samp_mutex; /* global data mutex */
+
+extern char *voGetStrArg ();
+
+
+
+
+/*****************************************************************************/
+
+
+
+/* SAMPDBG -- Toggle the XML-RPC tracing flag.
+ *
+ * Usage: cl> =sampDbg (ival) # explicitly set debug value
+ * cl> =sampDbg () # toggle debug value
+ */
+void
+func_sampDbg (void)
+{
+ register struct pfile *pfp;
+ struct operand o;
+ static int sampDebug = 0;
+ extern int nargs();
+
+
+ pfp = newtask->t_pfp;
+ if (nargs (pfp) > 0) {
+ pushbparams (pfp->pf_pp);
+ popop(); /* discard the $1 */
+ o = popop();
+ if (o.o_type != OT_INT)
+ cl_error (E_UERR, "samp trace arg should be an integer");
+ sampDebug = o.o_val.v_i;
+
+ } else /* toggle it */
+ sampDebug = (sampDebug+1) % 2;
+
+ unsetenv ("XMLRPC_TRACE_XML");
+ if (sampDebug)
+ setenv ("XMLRPC_TRACE_XML", "1", 1);
+
+ o.o_type = OT_BOOL;
+ o.o_val.v_i = sampDebug;
+ pushop (&o);
+}
+
+
+/* SAMPSTATUS -- Print or set the status of the samp interface.
+ */
+void
+func_sampStatus (int nargs)
+{
+ char *arg = NULL;
+ int i, stat = samp_registered, len = 0;
+ struct operand o;
+
+
+ if (nargs > 0) {
+
+ arg = voGetStrArg ();
+
+ if (strcasecmp ("on", arg) == 0 ||
+ strcasecmp ("start", arg) == 0) {
+ if (!samp_hubActive (samp))
+ cmd_sampStart ();
+ if (samp_registered && samp_hubActive (samp))
+ stat = 1;
+
+ } else if (strcasecmp ("off", arg) == 0 ||
+ strcasecmp ("stop", arg) == 0) {
+ if (samp_registered)
+ cmd_sampStop ();
+ stat = samp_registered;
+
+ } else if (strcasecmp ("restart", arg) == 0) {
+ cmd_sampRestart ();
+ stat = samp_registered;
+ }
+
+ if (arg) free ((void *) arg);
+ }
+
+ o.o_type = OT_STRING;
+ o.o_val.v_s = (stat ? "on" : "off");
+ pushop (&o);
+}
+
+
+/* SAMPHUBACCESS -- Check to see if a Hub is running and available.
+ */
+void
+func_sampHubAccess (int nargs)
+{
+ struct operand o;
+ int found = 0, verb;
+ char *home = envget ("HOME");
+ char path[SZ_LINE];
+
+ if (samp >= 0) {
+ verb = sampVerbose (samp, -1);
+ sampVerbose (samp, 0);
+ memset (path, 0, SZ_LINE);
+ sprintf (path, "%s/.samp", home);
+ found = (c_access (path, 0, 0) == YES);
+ sampVerbose (samp, verb);
+ }
+
+ o.o_type = OT_BOOL;
+ o.o_val.v_i = found;
+ pushop (&o);
+}
+
+
+/* SAMPACCESS -- Require an external application to be registered. We don't
+ * attempt to start the application ourselves, we simply report on whether
+ * it is currently available.
+ */
+void
+func_sampAccess (int nargs)
+{
+ char *appName = NULL, *app = NULL;
+ int i, found = 0, len = 0;
+ struct operand o;
+
+ if (nargs > 0) {
+ XINT clients;
+ char *pubId = NULL;
+ extern char *samp_getStringFromList(), *samp_app2id();
+
+ appName = voGetStrArg ();
+ if (strcasecmp ("hub", appName) == 0)
+ pubId = "hub";
+ else
+ pubId = samp_app2id (samp, appName);
+
+ /* Search the list for a matching appName
+ */
+ clients = samp_GetRegisteredClients (samp);
+ for (i=0; i < samp_listLen (clients); i++) {
+ app = samp_getStringFromList (clients, i);
+ len = min (strlen (pubId), strlen (app));
+ if (strncasecmp (pubId, app, len) == 0) {
+ found = 1;
+ break;
+ }
+ }
+ samp_freeList (clients);
+
+ } else
+ cl_error (E_UERR, "Application name must be specifified");
+
+ o.o_type = OT_BOOL;
+ o.o_val.v_i = found;
+ pushop (&o);
+}
+
+
+/* SAMPNAME -- Set (or print) a current SAMP application name.
+ */
+void
+func_sampName (int nargs)
+{
+ char *name = NULL, res[SZ_LINE];
+ struct operand o;
+
+ if (nargs == 1) {
+ name = voGetStrArg ();
+
+ samp_Metadata (samp, "samp.name", name);
+ samp_DeclareMetadata (samp);
+
+ /* Push the result operand on the stack.
+ */
+ strcpy (res, name);
+ o.o_type = OT_STRING;
+ o.o_val.v_s = res;
+ pushop (&o);
+
+ if (name) free ((void *) name);
+
+ } else if (nargs == 0) { /* list currently defined metadata */
+ extern XINT samp;
+ char *v = NULL;
+
+ /* Push the result operand on the stack.
+ */
+ v = samp_getMetadata(samp, "samp.name");
+ o.o_type = OT_STRING;
+ o.o_val.v_s = v;
+ pushop (&o);
+
+ } else
+ cl_error (E_UERR, "usage: sampName ([name])");
+}
+
+
+/* SAMPMETADATA -- Set (or print) a current SAMP metadata parameters.
+ */
+void
+func_sampMetadata (int nargs)
+{
+ char *param = NULL, *value = NULL;
+ struct operand o;
+
+ if (nargs == 2) {
+ value = voGetStrArg (); /* ars on stack in reverse order */
+ param = voGetStrArg ();
+
+ samp_Metadata (samp, param, value);
+ samp_DeclareMetadata (samp);
+
+ if (param) free ((void *) param);
+ if (value) free ((void *) value);
+
+ /* Push the result operand on the stack.
+ */
+ o.o_type = OT_STRING;
+ o.o_val.v_s = "ok";
+ pushop (&o);
+
+ } else if (nargs == 1) { /* list currently defined metadata */
+ param = voGetStrArg ();
+ samp_printMetadata (samp, param);
+
+ } else
+ cl_error (E_UERR, "usage: sampMetadata ([ [name], [value] ])");
+}
+
+
+/* CL_SAMPRESTART -- Restart the SAMP connection.
+ */
+void
+func_sampRestart (void)
+{
+ cmd_sampStop ();
+ cmd_sampStart ();
+}
+
+
+/* SAMPSTART -- Register with the SAMP Hub and begin messaging.
+ */
+void
+func_sampStart (void)
+{
+ if (!samp_registered) {
+ cmd_sampStart ();
+ samp_registered = 1;
+ } else
+ cmd_sampRestart(); /* disconnect and restart */
+}
+
+
+/* SAMPSTOP -- UnRegister from the SAMP Hub and stop messaging.
+ */
+void
+func_sampStop (void)
+{
+ if (samp_registered) {
+ samp_registered = 0;
+ cmd_sampStop ();
+ }
+}
+
+
+/* SAMPSEND -- Send a generic message. The format of a message on the
+ * cmdline must be:
+ *
+ * cl> sampSend <mtype> [to=<appName>] [<param>=<value> .....]
+ *
+ * If there is no 'to' argument the message will be broadcast to all
+ * recipients, otherwise this is expected to be the name of the receiving
+ * application. The mtype and parameters may correspond to well-known
+ * message type, in which case this is a low-level interface to sending
+ * those messages. However, this method can also be used to send arbitrary
+ * messages using private mtypes.
+ */
+#define MAX_ARGS 32
+
+void
+func_sampSend (void)
+{
+ register struct pfile *pfp;
+ char *mtype = NULL, *to = "all", *nam = NULL, *val = NULL;
+ char *args[MAX_ARGS];
+ int i, stat, numArgs;
+ struct operand o;
+ extern int nargs();
+
+
+ pfp = newtask->t_pfp;
+ numArgs = nargs (pfp);
+ if (numArgs > 0) {
+ pushbparams (pfp->pf_pp);
+
+ /* Simple, first argument has to be the mtype.
+ */
+ o = popop(); /* discard the $1 */
+ mtype = voGetStrArg ();
+
+ memset (args, 0, (MAX_ARGS * sizeof(char *)));
+ for (i=1; i < numArgs; i++) {
+ o = popop(); /* param nam or $N */
+ nam = o.o_val.v_s;
+
+ o = popop(); /* param nam or $N */
+ val = o.o_val.v_s;
+
+ if (strcmp (nam, "to") == 0)
+ to = val;
+ else {
+ args[i-1] = calloc (1, SZ_LINE);;
+ sprintf (args[i-1], "%s=%s", nam, val);
+ }
+ }
+
+ stat = samp_sendGeneric (samp, to, mtype, args);
+
+ for (i=0; i < (numArgs - 1); i++) {
+ if (args[i])
+ free ((void *) args[i]);
+ }
+
+ } else
+ cl_error (E_UERR, "sampSend: No message specified\n");
+
+ /* Push the result on the stack.
+ */
+ o.o_type = OT_BOOL;
+ o.o_val.v_i = stat;
+ pushop (&o);
+}
+
+
+
+/*****************************************************************************
+ * SAMP builtin function definitions. These are client-side commands.
+ ****************************************************************************/
+
+/**
+ * SAMP_HANDLER -- Add a user-defined handler to a specific mtype.
+ *
+ * Usage: sampHandler (mtype, cmd)
+ *
+ * Examples:
+ */
+
+void
+func_sampAddHandler (int nargs)
+{
+ char *mtype, *cmd, *arg1, *arg2;
+ int i, res = -1;
+ struct operand o;
+
+
+ o.o_type = OT_STRING;
+
+ if (nargs == 2) {
+ arg2 = voGetStrArg (); /* args on stack in reverse order */
+ arg1 = voGetStrArg ();
+
+ if (strncasecmp (arg1, "del", 3) == 0) {
+ /* samp handler delete foo.bar
+ */
+ mtype = arg2;
+ res = cl_delUserHandler (mtype); /* add the handler */
+
+ } else {
+ /* samp handler foo.bar "cmd $arg"
+ */
+ cmd = arg2; /* args on stack in reverse order */
+ mtype = arg1;
+ res = cl_addUserHandler (mtype, cmd); /* add the handler */
+ }
+ if (arg1) free ((void *) arg1);
+ if (arg2) free ((void *) arg2);
+
+ o.o_val.v_s = (res < 0 ? "error" : "ok");
+
+ } else if (nargs == 1) {
+ arg1 = mtype = voGetStrArg ();
+
+ if (strncasecmp (arg1, "del", 3) == 0) {
+ int i;
+
+ for (i=0; i < numHandlers; i++) {
+ memset (userHandlers[i].mtype, 0, SZ_FNAME);
+ memset (userHandlers[i].cmd, 0, SZ_FNAME);
+ }
+ numHandlers = 0;
+
+ } else {
+ for (i=0; i < numHandlers; i++) {
+ /* See if a handler is already defined for the given mtype.
+ */
+ if (strcmp (userHandlers[i].mtype, mtype) == 0) {
+ res = OK;
+ break;
+ }
+ }
+ }
+ o.o_val.v_s = (res < 0 ? "" : userHandlers[i].cmd);
+
+ } else { /* list currently defined handlers */
+ if (numHandlers == 0)
+ oprintf ("No SAMP handlers defined\n");
+ else {
+ for (i=0; i < numHandlers; i++)
+ oprintf ("%-20.20s %s\n",
+ userHandlers[i].mtype, userHandlers[i].cmd);
+ }
+ o.o_val.v_s = "ok";
+ }
+
+ pushop (&o); /* push the result operand on the stack */
+}
+
+
+/**
+ * SAMP_LOADIMAGE -- Send a 'image.load.fits' message to other clients.
+ *
+ * Usage: sampLoadImage (file|url [, to [, name [, tag ]]])
+ *
+ * Examples:
+ *
+ * 1) Broadcast the message to all subscribed clients:
+ *
+ * cl> = sampLoadImage ("http://iraf.noao.edu/votest/sif.fits")
+ * ok
+ *
+ * 2) Send the message to a named client:
+ *
+ * cl> = sampLoadImage ("data$foo.fits", "aladin")
+ * ok
+ *
+ * 3) Load the image with a given name:
+ *
+ * cl> = sampLoadImage ("/data/image001.fits", "aladin", "image1")
+ * ok
+ *
+ * If a message is sent to a named client that either isn't connected or
+ * returns an error, our result is the error string. On success, the string
+ * "ok" will be returned. It is not considered an error if a broadcast
+ * results in no clients actually receiving the message.
+ */
+
+void
+func_sampLoadImage (int nargs)
+{
+ char *what=NULL, *name=NULL, *tag=NULL, *to=NULL;
+ char url[SZ_PATHNAME+1], osfn[SZ_PATHNAME+1];
+ struct operand o;
+
+
+ /* Parse any remaining (optional) arguments. Remember that the args are
+ * on the stack in the reverse order! The 1st arg is required and will
+ * be either an ivo: identifier or is presumed to be the ShortName.
+ */
+ switch (nargs) {
+ case 4:
+ tag = voGetStrArg ();
+ /* fall thru */
+ case 3:
+ name = voGetStrArg ();
+ /* fall thru */
+ case 2:
+ to = voGetStrArg ();
+ /* fall thru */
+ case 1:
+ what = voGetStrArg ();
+ if (strncmp(what, "http:", 5) == 0 || strncmp(what, "file:", 5) == 0) {
+ strcpy (url, what);
+ } else {
+ c_fmapfn (what, osfn, SZ_PATHNAME);
+ if (c_access (osfn, READ_ONLY, 0) == NO) {
+ cl_error (E_UERR, "Cannot access image '%s'", what);
+ return;
+ }
+ sprintf (url, "file://%s", osfn);
+ }
+ break;
+
+ default:
+ cl_error (E_UERR, "sampImLoad: invalid number of arguments\n");
+ return;
+ }
+
+ if (name == NULL) name = strdup (what);
+ if (tag == NULL) tag = strdup ("foo");
+ if (to == NULL) to = strdup ("all");
+
+
+ /* Send the message.
+ */
+ o.o_type = OT_STRING;
+ if (samp_imageLoadFITS (samp, to, url, tag, name) != 0)
+ o.o_val.v_s = "ok";
+ else
+ o.o_val.v_s = samp_getErr (samp);
+
+ /* Push the result operand on the stack.
+ */
+ pushop (&o);
+
+ /* Clean up and return. FIXME
+ */
+ if (tag) free ((char *) tag);
+ if (name) free ((char *) name);
+ if (what) free ((char *) what);
+ if (to) free ((char *) to);
+}
+
+
+/**
+ * SAMP_LOADFITS -- Send a 'table.load.fits' message to other clients.
+ *
+ * Usage: sampLoadFITS (file|url [, to [, name [, tag ]]])
+ *
+ * Examples:
+ *
+ * 1) Broadcast the message to all subscribed clients:
+ *
+ * cl> = sampLoadFITS ("http://iraf.noao.edu/votest/sif.fits")
+ * ok
+ *
+ * 2) Send the message to a named client:
+ *
+ * cl> = sampLoadFITS ("data$foo.fits", "aladin")
+ * ok
+ *
+ * 3) Load the image with a given name:
+ *
+ * cl> = sampLoadFITS ("/data/image001.fits", "aladin", "image1")
+ * ok
+ *
+ * If a message is sent to a named client that either isn't connected or
+ * returns an error, our result is the error string. On success, the string
+ * "ok" will be returned. It is not considered an error if a broadcast
+ * results in no clients actually receiving the message.
+ */
+
+void
+func_sampLoadFITS (int nargs)
+{
+ char *what=NULL, *name=NULL, *tag=NULL, *to=NULL;
+ char url[SZ_PATHNAME+1], osfn[SZ_PATHNAME+1];
+ struct operand o;
+
+
+ /* Parse any remaining (optional) arguments. Remember that the args are
+ * on the stack in the reverse order! The 1st arg is required and will
+ * be either an ivo: identifier or is presumed to be the ShortName.
+ */
+ switch (nargs) {
+ case 4:
+ tag = voGetStrArg ();
+ /* fall thru */
+ case 3:
+ name = voGetStrArg ();
+ /* fall thru */
+ case 2:
+ to = voGetStrArg ();
+ /* fall thru */
+ case 1:
+ what = voGetStrArg ();
+ if (strncmp(what, "http:", 5) == 0 || strncmp(what, "file:", 5) == 0) {
+ strcpy (url, what);
+ } else {
+ c_fmapfn (what, osfn, SZ_PATHNAME);
+ if (c_access (osfn, READ_ONLY, 0) == NO) {
+ cl_error (E_UERR, "Cannot access image '%s'", what);
+ return;
+ }
+ sprintf (url, "file://%s", osfn);
+ }
+ break;
+
+ default:
+ cl_error (E_UERR, "sampImLoad: invalid number of arguments\n");
+ return;
+ }
+
+ if (name == NULL) name = strdup (what);
+ if (tag == NULL) tag = strdup ("foo");
+ if (to == NULL) to = strdup ("all");
+
+
+ /* Send the message.
+ */
+ o.o_type = OT_STRING;
+ if (samp_tableLoadFITS (samp, to, url, tag, name) != 0)
+ o.o_val.v_s = "ok";
+ else
+ o.o_val.v_s = samp_getErr (samp);
+
+ /* Push the result operand on the stack.
+ */
+ pushop (&o);
+
+ /* Clean up and return.
+ */
+ if (tag) free ((char *) tag);
+ if (name) free ((char *) name);
+ if (what) free ((char *) what);
+ if (to) free ((char *) to);
+}
+
+
+/**
+ * SAMP_LOADVOTABLE -- Send a 'table.load.votable' message to other clients.
+ *
+ * Usage: sampLoadVOTable (file|url [, to [, name [, tag ]]])
+ *
+ * Examples:
+ *
+ * 1) Broadcast the message to all subscribed clients:
+ *
+ * cl> = sampLoadFITS ("http://iraf.noao.edu/votest/sif.fits")
+ * ok
+ *
+ * 2) Send the message to a named client:
+ *
+ * cl> = sampLoadFITS ("data$foo.fits", "aladin")
+ * ok
+ *
+ * 3) Load the image with a given name:
+ *
+ * cl> = sampLoadFITS ("/data/image001.fits", "aladin", "image1")
+ * ok
+ *
+ * If a message is sent to a named client that either isn't connected or
+ * returns an error, our result is the error string. On success, the string
+ * "ok" will be returned. It is not considered an error if a broadcast
+ * results in no clients actually receiving the message.
+ */
+
+void
+func_sampLoadVOTable (int nargs)
+{
+ char *what=NULL, *name=NULL, *tag=NULL, *to=NULL;
+ char url[SZ_PATHNAME+1], osfn[SZ_PATHNAME+1];
+ struct operand o;
+
+
+ /* Parse any remaining (optional) arguments. Remember that the args are
+ * on the stack in the reverse order! The 1st arg is required and will
+ * be either an ivo: identifier or is presumed to be the ShortName.
+ */
+ switch (nargs) {
+ case 4:
+ tag = voGetStrArg ();
+ /* fall thru */
+ case 3:
+ name = voGetStrArg ();
+ /* fall thru */
+ case 2:
+ to = voGetStrArg ();
+ /* fall thru */
+ case 1:
+ what = voGetStrArg ();
+ if (strncmp(what, "http:", 5) == 0 || strncmp(what, "file:", 5) == 0) {
+ strcpy (url, what);
+ } else {
+ c_fmapfn (what, osfn, SZ_PATHNAME);
+ if (c_access (osfn, READ_ONLY, 0) == NO) {
+ cl_error (E_UERR, "Cannot access file '%s'", what);
+ return;
+ }
+ sprintf (url, "file://%s", osfn);
+ }
+ break;
+
+ default:
+ cl_error (E_UERR, "sampLoadVOTable: invalid number of arguments\n");
+ return;
+ }
+
+ if (name == NULL) name = strdup (what);
+ if (tag == NULL) tag = strdup ("foo");
+ if (to == NULL) to = strdup ("all");
+
+
+ /* Send the message.
+ */
+ o.o_type = OT_STRING;
+ if (samp_tableLoadVOTable (samp, to, url, tag, name) != 0)
+ o.o_val.v_s = "ok";
+ else
+ o.o_val.v_s = samp_getErr (samp);
+
+ /* Push the result operand on the stack.
+ */
+ pushop (&o);
+
+ /* Clean up and return.
+ */
+ if (tag) free ((char *) tag);
+ if (name) free ((char *) name);
+ if (what) free ((char *) what);
+ if (to) free ((char *) to);
+}
+
+
+/**
+ * SAMP_SHOWROW -- Send a 'table.highlight.row' message to other clients.
+ *
+ * Usage: sampShowRow (url, id, row [, to])
+ */
+
+void
+func_sampShowRow (int nargs)
+{
+ register int i, row=0, stat = 0;
+ char *to=NULL, *srow=NULL, *what=NULL, *tblId=NULL;
+ char osfn[SZ_PATHNAME], url[SZ_URL];
+ struct operand o;
+
+
+ memset (url, 0, SZ_URL);
+ switch (nargs) {
+ case 4:
+ to = voGetStrArg ();
+ /* fall thru */
+ case 3:
+ row = atoi ((srow = voGetStrArg ()));
+ /* fall thru */
+ case 2:
+ tblId = voGetStrArg ();
+ /* fall thru */
+ case 1:
+ what = voGetStrArg ();
+ if (strncmp(what, "http:", 5) == 0 || strncmp(what, "file:", 5) == 0) {
+ strcpy (url, what);
+ } else {
+ c_fmapfn (what, osfn, SZ_PATHNAME);
+ if (c_access (osfn, READ_ONLY, 0) == NO) {
+ cl_error (E_UERR, "Cannot access file '%s'", what);
+ return;
+ }
+ sprintf (url, "file://%s", osfn);
+ }
+ break;
+ default:
+ cl_error (E_UERR, "usage: sampShowRow (url, tblId, row[, to])");
+ return;
+ }
+
+ if (!to) to = strdup ("all");
+
+ stat = samp_tableHighlightRow (samp, to, tblId, url, row);
+
+ if (to) free ((void *) to);
+ if (srow) free ((void *) srow);
+ if (tblId) free ((void *) tblId);
+ if (what) free ((void *) what);
+
+ /* Push the result operand on the stack.
+ */
+ o.o_type = OT_STRING;
+ o.o_val.v_s = (stat != 0 ? "ok" : samp_getErr(samp));
+ pushop (&o);
+}
+
+
+/**
+ * SAMP_SELECTROWLIST -- Send a 'table.select.rowList' message to other
+ * clients.
+ *
+ * Usage: sampSelectRowList (url, id, row [, to])
+ */
+
+#define MAX_ROWSELECT 1024
+
+void
+func_sampSelectRowList (int nargs)
+{
+ int i, nrows = 0, stat = 0, rows[MAX_ROWSELECT];
+ char *to=NULL, *srow=NULL, *what=NULL, *tblId=NULL;
+ char osfn[SZ_PATHNAME], url[SZ_URL], *ip, *n;
+ struct operand o;
+
+
+ memset (url, 0, SZ_URL);
+ switch (nargs) {
+ case 4:
+ to = voGetStrArg ();
+ /* fall thru */
+ case 3:
+ srow = voGetStrArg ();
+ /* fall thru */
+ case 2:
+ tblId = voGetStrArg ();
+ /* fall thru */
+ case 1:
+ what = voGetStrArg ();
+ if (strncmp(what, "http:", 5) == 0 || strncmp(what, "file:", 5) == 0) {
+ strcpy (url, what);
+ } else {
+ c_fmapfn (what, osfn, SZ_PATHNAME);
+ if (c_access (osfn, READ_ONLY, 0) == NO) {
+ cl_error (E_UERR, "Cannot access file '%s'", what);
+ return;
+ }
+ sprintf (url, "file://%s", osfn);
+ }
+ break;
+ default:
+ cl_error (E_UERR, "usage: sampShowRow (url, tblId, row[, to])");
+ return;
+ }
+
+ if (!to) to = strdup ("all");
+
+ /* Convert the row list string into an int array.
+ */
+ for (ip=srow, n=srow, nrows=0; n; ip=n ) {
+ if ( (n = strchr (ip, (int) ',')) )
+ *n++ = '\0';
+ rows[nrows++] = atoi (ip);
+ }
+
+ stat = samp_tableSelectRowList (samp, to, tblId, url, rows, nrows);
+
+ if (to) free ((void *) to);
+ if (srow) free ((void *) srow);
+ if (tblId) free ((void *) tblId);
+ if (what) free ((void *) what);
+
+ /* Push the result operand on the stack.
+ */
+ o.o_type = OT_STRING;
+ o.o_val.v_s = (stat != 0 ? "ok" : samp_getErr(samp));
+ pushop (&o);
+}
+
+
+/**
+ * SAMP_POINTAT -- Send a 'coords.pointAt.sky' message to other clients.
+ *
+ * Usage: sampPointAt (ra, dec[, to])
+ */
+
+void
+func_sampPointAt (int nargs)
+{
+ register int i, stat;
+ char *arg = NULL, to[SZ_LINE];
+ float ra = -1.0, dec = 0.0;
+ struct operand o;
+
+ if (nargs > 0) {
+ strcpy (to, "all");
+ for (i=0; i < nargs; i++) {
+ arg = voGetStrArg (); /* args on stack in reverse order */
+
+ if (isalpha ((int) arg[0])) /* recipient arg */
+ strcpy (to, arg);
+ else if (ra < 0) /* not initialized yet */
+ dec = atof (arg);
+ else
+ ra = atof (arg);
+
+ if (arg) free ((char *) arg);
+ }
+
+ stat = samp_coordPointAtSky (samp, to, ra, dec);
+
+ /* Push the result operand on the stack.
+ */
+ o.o_type = OT_STRING;
+ o.o_val.v_s = (stat < 0 ? "error" : "ok");
+ pushop (&o);
+
+ } else
+ cl_error (E_UERR, "usage: sampPointAt (ra_deg, dec_deg)");
+}
+
+
+/**
+ * SAMP_SPECLOAD -- Send a 'spec.load.ssa-generic' message to other clients.
+ *
+ * Usage: sampSpecLoad ()
+ */
+
+void
+func_sampSpecLoad (int nargs)
+{
+}
+
+
+/**
+ * SAMP_BIBCODELOAD -- Send a 'bibcode.load' message to other clients.
+ *
+ * Usage: sampBibcodeLoad (bibcode[, to])
+ */
+
+void
+func_sampBibcodeLoad (int nargs)
+{
+ register int stat = 0;
+ char *to=NULL, *bibcode=NULL;
+ struct operand o;
+
+
+ switch (nargs) {
+ case 2:
+ to = voGetStrArg ();
+ /* fall thru */
+ case 1:
+ bibcode = voGetStrArg ();
+ break;
+ default:
+ cl_error (E_UERR, "usage: sampShowRow (tblId, url, row[, to])");
+ return;
+ }
+
+ if (!to) to = strdup ("all");
+
+ stat = samp_bibLoad (samp, to, bibcode);
+
+ if (to) free ((void *) to);
+ if (bibcode) free ((void *) bibcode);
+
+ /* Push the result operand on the stack.
+ */
+ o.o_type = OT_STRING;
+ o.o_val.v_s = (stat != 0 ? "ok" : samp_getErr(samp));
+ pushop (&o);
+}
+
+
+/**
+ * SAMP_CMDEXEC -- Send a 'client.cmd.exec' message to other clients.
+ *
+ * Usage: sampCmdExec (cmd[, to]))
+ */
+
+void
+func_sampCmdExec (int nargs)
+{
+ register int stat = 0;
+ char *to=NULL, *cmd=NULL;
+ struct operand o;
+
+
+ switch (nargs) {
+ case 2:
+ to = voGetStrArg ();
+ /* fall thru */
+ case 1:
+ cmd = voGetStrArg ();
+ break;
+ default:
+ cl_error (E_UERR, "usage: sampCmdExec (cmd[, to])");
+ return;
+ }
+
+ if (!to) to = strdup ("all");
+
+ stat = samp_cmdExec (samp, to, cmd);
+
+ if (to) free ((void *) to);
+ if (cmd) free ((void *) cmd);
+
+ /* Push the result operand on the stack.
+ */
+ o.o_type = OT_STRING;
+ o.o_val.v_s = (stat != 0 ? "ok" : samp_getErr(samp));
+ pushop (&o);
+}
+
+
+/**
+ * SAMP_ENVGET -- Send a 'client.env.get' message to other clients.
+ *
+ * Usage: sampEnvGet (param[, to]))
+ */
+
+void
+func_sampEnvGet (int nargs)
+{
+ char *res=NULL, *to=NULL, *param=NULL;
+ struct operand o;
+
+
+ switch (nargs) {
+ case 2:
+ to = voGetStrArg ();
+ /* fall thru */
+ case 1:
+ param = voGetStrArg ();
+ break;
+ default:
+ cl_error (E_UERR, "usage: sampEnvGet (param[, to])");
+ return;
+ }
+
+ if (!to) to = strdup ("all");
+
+ res = samp_envGet (samp, to, param);
+
+ if (to) free ((void *) to);
+ if (param) free ((void *) param);
+
+ /* Push the result operand on the stack.
+ */
+ o.o_type = OT_STRING;
+ o.o_val.v_s = res;
+ pushop (&o);
+}
+
+
+/**
+ * SAMP_ENVSET -- Send a 'client.env.set' message to other clients.
+ *
+ * Usage: sampEnvSet (param, val[, to]))
+ */
+
+void
+func_sampEnvSet (int nargs)
+{
+ register int stat = 0;
+ char *res=NULL, *to=NULL, *param=NULL, *val=NULL;
+ struct operand o;
+
+
+ switch (nargs) {
+ case 3:
+ to = voGetStrArg ();
+ /* fall thru */
+ case 2:
+ val = voGetStrArg ();
+ /* fall thru */
+ case 1:
+ param = voGetStrArg ();
+ break;
+ default:
+ cl_error (E_UERR, "usage: sampEnvSet (param, val[, to])");
+ return;
+ }
+
+ if (!to) to = strdup ("all");
+
+ stat = samp_envSet (samp, to, param, val);
+
+ if (to) free ((void *) to);
+ if (param) free ((void *) param);
+ if (val) free ((void *) val);
+
+ /* Push the result operand on the stack.
+ */
+ o.o_type = OT_STRING;
+ o.o_val.v_s = (stat != 0 ? "ok" : samp_getErr(samp));
+ pushop (&o);
+}
+
+
+/**
+ * SAMP_PARAMGET -- Send a 'client.param.get' message to other clients.
+ *
+ * Usage: sampParamGet (param[, to]))
+ */
+
+void
+func_sampParamGet (int nargs)
+{
+ char *res=NULL, *to=NULL, *param=NULL;
+ struct operand o;
+
+
+ switch (nargs) {
+ case 2:
+ to = voGetStrArg ();
+ /* fall thru */
+ case 1:
+ param = voGetStrArg ();
+ break;
+ default:
+ cl_error (E_UERR, "usage: sampParamGet (param[, to])");
+ return;
+ }
+
+ if (!to) to = strdup ("all");
+
+ res = samp_paramGet (samp, to, param);
+
+ if (to) free ((void *) to);
+ if (param) free ((void *) param);
+
+ /* Push the result operand on the stack.
+ */
+ o.o_type = OT_STRING;
+ o.o_val.v_s = res;
+ pushop (&o);
+}
+
+
+/**
+ * SAMP_PARAMSET -- Send a 'client.param.set' message to other clients.
+ *
+ * Usage: sampParamSet (param, val[, to]))
+ */
+
+void
+func_sampParamSet (int nargs)
+{
+ register int stat = 0;
+ char *res=NULL, *to=NULL, *param=NULL, *val=NULL;
+ struct operand o;
+
+
+ switch (nargs) {
+ case 3:
+ to = voGetStrArg ();
+ /* fall thru */
+ case 2:
+ val = voGetStrArg ();
+ /* fall thru */
+ case 1:
+ param = voGetStrArg ();
+ break;
+ default:
+ cl_error (E_UERR, "usage: sampParamSet (param, val[, to])");
+ return;
+ }
+
+ if (!to) to = strdup ("all");
+
+ stat = samp_paramSet (samp, to, param, val);
+
+ if (to) free ((void *) to);
+ if (param) free ((void *) param);
+ if (val) free ((void *) val);
+
+ /* Push the result operand on the stack.
+ */
+ o.o_type = OT_STRING;
+ o.o_val.v_s = (stat != 0 ? "ok" : samp_getErr(samp));
+ pushop (&o);
+}
generated by cgit (git 2.34.1) at 2025-09-20 16:30:57 -0400