Hamlib/tcl/tclrig.c

/*
 *  Hamlib tcl/tk bindings - rig
 *  Copyright (c) 2001,2002 by Stephane Fillod
 *
 *		$Id: tclrig.c,v 1.4 2002-08-26 21:26:06 fillods Exp $
 *
 *   This library is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU Library General Public License as
 *   published by the Free Software Foundation; either version 2 of
 *   the License, or (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU Library General Public License for more details.
 *
 *   You should have received a copy of the GNU Library General Public
 *   License along with this library; if not, write to the Free Software
 *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <string.h>
#include <tcl.h>
#include <hamlib/rig.h>
#include <misc.h>

#include "tclrig.h"


#define ARG_IN1  0x01
#define ARG_OUT1 0x02
#define ARG_IN2  0x04
#define ARG_OUT2 0x08
#define ARG_IN3  0x10
#define ARG_OUT3 0x20
#define ARG_IN4  0x40
#define ARG_OUT4 0x80

#define ARG_IN  (ARG_IN1|ARG_IN2|ARG_IN3|ARG_IN4)
#define ARG_OUT  (ARG_OUT1|ARG_OUT2|ARG_OUT3|ARG_OUT4)

struct cmd_table {
	const char *name;
    int (*rig_routine)(RIG*, const struct cmd_table*, 
					Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]);
	int flags;
	const char *arg1;
	const char *arg2;
	const char *arg3;
};

#define declare_proto_rig(f) static int (f)(RIG *rig, \
			const struct cmd_table *cmd, \
			Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])

declare_proto_rig(tclrig_open);
declare_proto_rig(tclrig_close);
declare_proto_rig(tclrig_cleanup);
declare_proto_rig(set_conf);
declare_proto_rig(get_conf);
declare_proto_rig(set_freq);
declare_proto_rig(get_freq);
declare_proto_rig(set_mode);
declare_proto_rig(get_mode);
declare_proto_rig(set_vfo);
declare_proto_rig(get_vfo);
declare_proto_rig(get_info);
declare_proto_rig(get_strength);
declare_proto_rig(set_level);
declare_proto_rig(get_level);
declare_proto_rig(set_func);
declare_proto_rig(get_func);
declare_proto_rig(set_parm);
declare_proto_rig(get_parm);
declare_proto_rig(set_split_freq);
declare_proto_rig(get_split_freq);
declare_proto_rig(set_split_mode);
declare_proto_rig(get_split_mode);
declare_proto_rig(set_split);
declare_proto_rig(get_split);
declare_proto_rig(set_bank);
declare_proto_rig(set_mem);
declare_proto_rig(get_mem);
declare_proto_rig(vfo_op);
declare_proto_rig(scan);
declare_proto_rig(set_rptr_shift);
declare_proto_rig(get_rptr_shift);
declare_proto_rig(set_rptr_offs);
declare_proto_rig(get_rptr_offs);
declare_proto_rig(set_ctcss_tone);
declare_proto_rig(get_ctcss_tone);
declare_proto_rig(set_dcs_code);
declare_proto_rig(get_dcs_code);
declare_proto_rig(set_ctcss_sql);
declare_proto_rig(get_ctcss_sql);
declare_proto_rig(set_dcs_sql);
declare_proto_rig(get_dcs_sql);
declare_proto_rig(set_ts);
declare_proto_rig(get_ts);
declare_proto_rig(set_rit);
declare_proto_rig(get_rit);
declare_proto_rig(set_xit);
declare_proto_rig(get_xit);
#if 0
declare_proto_rig(set_ptt);
declare_proto_rig(get_ptt);
declare_proto_rig(get_dcd);
declare_proto_rig(power2mW);
declare_proto_rig(set_channel);
declare_proto_rig(get_channel);
declare_proto_rig(set_trn);
declare_proto_rig(get_trn);
declare_proto_rig(set_powerstat);
declare_proto_rig(get_powerstat);
declare_proto_rig(reset);
declare_proto_rig(set_ant);
declare_proto_rig(get_ant);
declare_proto_rig(send_dtmf);
declare_proto_rig(recv_dtmf);
declare_proto_rig(send_morse);
#endif

/*
 */
static struct cmd_table cmd_list[] = {
		{ "open", tclrig_open },
		{ "close", tclrig_close },
		{ "cleanup", tclrig_cleanup },
		{ "set_conf", set_conf, ARG_IN, "Token", "Value" },
		{ "get_conf", get_conf, ARG_IN1|ARG_OUT2, "Token", "Value" },
		{ "set_freq", set_freq, ARG_IN, "Frequency" },
		{ "get_freq", get_freq, ARG_OUT, "Frequency" },
		{ "set_mode", set_mode, ARG_IN, "Mode", "Passband" },
		{ "get_mode", get_mode, ARG_OUT, "Mode", "Passband" },
		{ "set_vfo", set_vfo, ARG_IN, "VFO" },
		{ "get_vfo", get_vfo, ARG_OUT, "VFO" },
		{ "get_strength", get_strength, ARG_OUT, "Strength" },
		{ "set_level", set_level, ARG_IN, "Level", "Value" },
		{ "get_level", get_level, ARG_IN1|ARG_OUT2, "Level", "Value" },
		{ "set_func", set_func, ARG_IN, "Func", "Func status" },
		{ "get_func", get_func, ARG_IN1|ARG_OUT2, "Func", "Func status" },
		{ "set_parm", set_parm, ARG_IN, "Parm", "Value" },
		{ "get_parm", get_parm, ARG_IN1|ARG_OUT2, "Parm", "Value" },
		{ "set_bank", set_bank, ARG_IN, "Bank" },
		{ "set_mem", set_mem, ARG_IN, "Memory#" },
		{ "get_mem", get_mem, ARG_OUT, "Memory#" },
		{ "vfo_op", vfo_op, ARG_IN, "Mem/VFO op" },
		{ "set_split_freq", set_split_freq, ARG_IN, "Tx frequency" },
		{ "get_split_freq", get_split_freq, ARG_OUT, "Tx frequency" },
		{ "set_split_mode", set_split_mode, ARG_IN, "Mode", "Passband" },
		{ "get_split_mode", get_split_mode, ARG_OUT, "Mode", "Passband" },
		{ "set_split", set_split, ARG_IN, "Split mode" },
		{ "get_split", get_split, ARG_OUT, "Split mode" },
		{ "scan", scan, ARG_IN, "Scan fct", "Channel" },
		{ "set_rptr_shift", set_rptr_shift, ARG_IN, "Rptr shift" },
		{ "get_rptr_shift", get_rptr_shift, ARG_OUT, "Rptr shift" },
		{ "set_rptr_offs", set_rptr_offs, ARG_IN, "Rptr offset" },
		{ "get_rptr_offs", get_rptr_offs, ARG_OUT, "Rptr offset" },
		{ "set_ctcss_tone", set_ctcss_tone, ARG_IN, "CTCSS tone" },
		{ "get_ctcss_tone", get_ctcss_tone, ARG_OUT, "CTCSS tone" },
		{ "set_dcs_code", set_dcs_code, ARG_IN, "DCS code" },
		{ "get_dcs_code", get_dcs_code, ARG_OUT, "DCS code" },
		{ "set_ctcss_sql", set_ctcss_sql, ARG_IN, "CTCSS tone" },
		{ "get_ctcss_sql", get_ctcss_sql, ARG_OUT, "CTCSS tone" },
		{ "set_dcs_sql", set_dcs_sql, ARG_IN, "DCS code" },
		{ "get_dcs_sql", get_dcs_sql, ARG_OUT, "DCS code" },
		{ "set_ts", set_ts, ARG_IN, "Tuning step" },
		{ "get_ts", get_ts, ARG_OUT, "Tuning step" },
		{ "set_rit", set_rit, ARG_IN, "RIT" },
		{ "get_rit", get_rit, ARG_OUT, "RIT" },
		{ "set_xit", set_xit, ARG_IN, "XIT" },
		{ "get_xit", get_xit, ARG_OUT, "XIT" },
#if 0
		{ "set_ptt", set_ptt, ARG_IN, "PTT" },
		{ "get_ptt", get_ptt, ARG_OUT, "PTT" },
		{ "set_channel", set_channel, ARG_IN,  /* huh! */ },
		{ "get_channel", get_channel, ARG_IN, "Channel" },
		{ "set_trn", set_trn, ARG_IN, "Transceive" },
		{ "get_trn", get_trn, ARG_OUT, "Transceive" },
		{ "power2mW", power2mW },
#endif
		{ "get_info", get_info, ARG_OUT, "Info" },
		{ NULL, NULL },

};

#define MAXNAMSIZ 32
#define MAXNBOPT 100	/* max number of different options */


/*
 * TODO: use Lex and some kind of hash table
 */
static struct cmd_table *parse_cmd(const char *name)
{
		int i;

		for (i=0; i<MAXNBOPT && cmd_list[i].name != NULL; i++)
				if (!strncmp(name, cmd_list[i].name, MAXNAMSIZ))
						return &cmd_list[i];
		return NULL;
}


/*
 * since there's no long long support in tcl API, 
 * freq_t is mapped to double object, which has enough
 * significant digits for frequencies up to tens of GHz.
 */

int
DoRigLib(ClientData clientData, Tcl_Interp *interp,
       int objc, Tcl_Obj *CONST objv[])
{
	Tcl_Obj *resultPtr;
	int    retcode;
	char *subcmd;

	/* objc gives the number of "objects" = arguments to
	the command */
	if (objc != 2 && objc != 3) {
		Tcl_WrongNumArgs(interp, 1, objv, "cmd ?model?");
		return TCL_ERROR;
	}
	
	/* Process the arguments
	objv is an array holding the arguments */

  /* Use Tcl_GetIntFromObj to put an integer value
       into a variable from the argument list */

	subcmd = Tcl_GetString(objv[1]);
	resultPtr = Tcl_GetObjResult(interp);

	/* TODO: make use of flex here! */

	if (!strcasecmp(subcmd, "version")) {
		Tcl_SetStringObj(resultPtr, hamlib_version, -1);
	} else if (!strcasecmp(subcmd, "help")) {
		Tcl_SetStringObj(resultPtr, "no help yet!", -1);
	} else if (!strcasecmp(subcmd, "init")) {
		rig_model_t model;
		RIG *tcl_rig;
		char rigcmd_name[16];
		static int rigcmd_cpt=0;

		retcode = Tcl_GetIntFromObj(interp, objv[2], (int*)&model);
		if (retcode != TCL_OK)
				return retcode;
		tcl_rig = rig_init(model);
		if (!tcl_rig)
				return TCL_ERROR;
		sprintf(rigcmd_name, "rig%d", rigcmd_cpt++);
		Tcl_CreateObjCommand(interp, rigcmd_name, DoRig,
	       (ClientData)tcl_rig, (Tcl_CmdDeleteProc *)NULL);
		Tcl_SetStringObj(resultPtr, rigcmd_name, -1);
	} else {
		return TCL_ERROR;
	}
	return TCL_OK;
}

int
DoRig(ClientData clientData, Tcl_Interp *interp,
       int objc, Tcl_Obj *CONST objv[])
{
	int    retcode;
	char *subcmd;
	RIG *tcl_rig = (RIG*)clientData;
	struct cmd_table *cmd_entry;

	if (!tcl_rig)
			return TCL_ERROR;

	/* objc gives the number of "objects" = arguments to
	the command */
	if (objc < 2) {
		Tcl_WrongNumArgs(interp, 1, objv, "var1 var2 ?var3?");
		return TCL_ERROR;
	}
	
	/* Process the arguments
	objv is an array holding the arguments */

  /* Use Tcl_GetIntFromObj to put an integer value
       into a variable from the argument list */

	subcmd = Tcl_GetString(objv[1]);
	cmd_entry = parse_cmd(subcmd);
	if (!cmd_entry) {
			/* unknow subcmd */
		return TCL_ERROR;
	}

	retcode = (*cmd_entry->rig_routine)(tcl_rig, 
					cmd_entry, interp, objc, objv);
				
	if (retcode != RIG_OK ) {
			/* FIXME: set Tcl error, and retcode can be TCL_ERROR! */
		fprintf(stderr, "%s: %s\n", cmd_entry->name, rigerror(retcode));
		return TCL_ERROR;
	}

	return TCL_OK;
}

/*
 * static int (f)(RIG *rig, const struct cmd_table *cmd, 
 *			Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])
 */

declare_proto_rig(tclrig_open)
{
		return rig_open(rig);
}

declare_proto_rig(tclrig_close)
{
		return rig_close(rig);
}

/*
 * FIXME: delete rig%d tcl command
 */
declare_proto_rig(tclrig_cleanup)
{
		return rig_cleanup(rig);
}

declare_proto_rig(set_conf)
{
		token_t tok;

		tok = rig_token_lookup(rig, Tcl_GetString(objv[2]));

		return rig_set_conf(rig, tok, Tcl_GetString(objv[3]));
}

declare_proto_rig(get_conf)
{
		int status;
		token_t tok;
		Tcl_Obj *resultPtr;
		char buf[255];

		resultPtr = Tcl_GetObjResult(interp);

		tok = rig_token_lookup(rig, Tcl_GetString(objv[2]));

		status = rig_get_conf(rig, tok, buf);
		if (status != RIG_OK)
				return status;

		Tcl_SetStringObj(resultPtr, buf, -1);

		return RIG_OK;
}

declare_proto_rig(set_freq)
{
		int status;
		double d;
		freq_t freq;

		status = Tcl_GetDoubleFromObj(interp, objv[2], &d);
		if (status != TCL_OK)
			return status;
		freq = (freq_t)d;

		return rig_set_freq(rig, RIG_VFO_CURR, freq);
}

declare_proto_rig(get_freq)
{
		int status;
		freq_t freq;
		Tcl_Obj *resultPtr;

		resultPtr = Tcl_GetObjResult(interp);

		status = rig_get_freq(rig, RIG_VFO_CURR, &freq);
		if (status != RIG_OK)
				return status;
		Tcl_SetDoubleObj(resultPtr, (double)freq);

		return RIG_OK;
}

declare_proto_rig(get_strength)
{
		int status;
		value_t val;
		Tcl_Obj *resultPtr;

		resultPtr = Tcl_GetObjResult(interp);

		status = rig_get_strength(rig, RIG_VFO_CURR, &val);
		if (status != RIG_OK)
				return status;
		Tcl_SetIntObj(resultPtr, val.i);

		return RIG_OK;
}

declare_proto_rig(set_mode)
{
		int status;
		rmode_t mode;
		pbwidth_t width;

		mode = parse_mode(Tcl_GetString(objv[2]));
		status = Tcl_GetLongFromObj(interp, objv[3], &width);
		if (status != TCL_OK)
			return status;
		return rig_set_mode(rig, RIG_VFO_CURR, mode, width);
}


declare_proto_rig(get_mode)
{
		int status;
		rmode_t mode;
		pbwidth_t width;
		Tcl_Obj *resultPtr;

		resultPtr = Tcl_GetObjResult(interp);

		status = rig_get_mode(rig, RIG_VFO_CURR, &mode, &width);
		if (status != RIG_OK)
				return status;

		/* FIXME: return also width */
		Tcl_SetStringObj(resultPtr, strrmode(mode), -1);

		return RIG_OK;
}


declare_proto_rig(set_vfo)
{
		vfo_t vfo;

		vfo = parse_vfo(Tcl_GetString(objv[2]));
		return rig_set_vfo(rig, vfo);
}


declare_proto_rig(get_vfo)
{
		int status;
		vfo_t vfo;
		Tcl_Obj *resultPtr;

		resultPtr = Tcl_GetObjResult(interp);

		vfo = parse_vfo(Tcl_GetString(objv[2]));
		status = rig_get_vfo(rig, &vfo);
		if (status != RIG_OK)
				return status;

		Tcl_SetStringObj(resultPtr, strvfo(vfo), -1);
		return RIG_OK;
}

declare_proto_rig(set_split)
{
		split_t split;
		int arg;

		Tcl_GetIntFromObj(interp, objv[2], &arg);
		split = arg ? RIG_SPLIT_ON : RIG_SPLIT_OFF;
		return rig_set_split(rig, RIG_VFO_CURR, split);
}


declare_proto_rig(get_split)
{
		int status;
		split_t split;
		Tcl_Obj *resultPtr;

		resultPtr = Tcl_GetObjResult(interp);

		status = rig_get_split(rig, RIG_VFO_CURR, &split);
		if (status != RIG_OK)
				return status;

		Tcl_SetIntObj(resultPtr, split);
		return RIG_OK;
}

declare_proto_rig(scan)
{
		scan_t scan;
		int ch;

		scan = parse_scan(Tcl_GetString(objv[2]));
		Tcl_GetIntFromObj(interp, objv[3], &ch);
		return rig_scan(rig, RIG_VFO_CURR, scan, ch);
}


declare_proto_rig(vfo_op)
{
		vfo_op_t op;

		op = parse_vfo_op(Tcl_GetString(objv[2]));
		return rig_vfo_op(rig, RIG_VFO_CURR, op);
}


declare_proto_rig(set_bank)
{
		int bank;

		Tcl_GetIntFromObj(interp, objv[2], &bank);
		return rig_set_bank(rig, RIG_VFO_CURR, bank);
}


declare_proto_rig(set_mem)
{
		int ch;

		Tcl_GetIntFromObj(interp, objv[2], &ch);
		return rig_set_mem(rig, RIG_VFO_CURR, ch);
}


declare_proto_rig(get_mem)
{
		int status;
		int ch;
		Tcl_Obj *resultPtr;

		resultPtr = Tcl_GetObjResult(interp);

		status = rig_get_mem(rig, RIG_VFO_CURR, &ch);
		if (status != RIG_OK)
				return status;

		Tcl_SetIntObj(resultPtr, ch);
		return RIG_OK;
}



declare_proto_rig(set_split_freq)
{
		int status;
		double d;
		freq_t freq;

		status = Tcl_GetDoubleFromObj(interp, objv[2], &d);
		if (status != TCL_OK)
			return status;
		freq = (freq_t)d;

		return rig_set_split_freq(rig, RIG_VFO_CURR, freq);
}

declare_proto_rig(get_split_freq)
{
		int status;
		freq_t freq;
		Tcl_Obj *resultPtr;

		resultPtr = Tcl_GetObjResult(interp);

		status = rig_get_split_freq(rig, RIG_VFO_CURR, &freq);
		if (status != RIG_OK)
				return status;
		Tcl_SetDoubleObj(resultPtr, (double)freq);

		return RIG_OK;
}

declare_proto_rig(set_split_mode)
{
		int status;
		rmode_t mode;
		pbwidth_t width;

		mode = parse_mode(Tcl_GetString(objv[2]));
		status = Tcl_GetLongFromObj(interp, objv[3], &width);
		if (status != TCL_OK)
			return status;
		return rig_set_split_mode(rig, RIG_VFO_CURR, mode, width);
}


declare_proto_rig(get_split_mode)
{
		int status;
		rmode_t mode;
		pbwidth_t width;
		Tcl_Obj *resultPtr;

		resultPtr = Tcl_GetObjResult(interp);

		status = rig_get_split_mode(rig, RIG_VFO_CURR, &mode, &width);
		if (status != RIG_OK)
				return status;

		/* FIXME: return also width */
		Tcl_SetStringObj(resultPtr, strrmode(mode), -1);

		return RIG_OK;
}

declare_proto_rig(set_rptr_shift)
{
		rptr_shift_t rptr_shift;

		rptr_shift = parse_rptr_shift(Tcl_GetString(objv[2]));
		return rig_set_rptr_shift(rig, RIG_VFO_CURR, rptr_shift);
}


declare_proto_rig(get_rptr_shift)
{
		int status;
		rptr_shift_t rptr_shift;
		Tcl_Obj *resultPtr;

		resultPtr = Tcl_GetObjResult(interp);

		status = rig_get_rptr_shift(rig, RIG_VFO_CURR, &rptr_shift);
		if (status != RIG_OK)
				return status;

		/* FIXME: return also width */
		Tcl_SetStringObj(resultPtr, strptrshift(rptr_shift), -1);

		return RIG_OK;
}

declare_proto_rig(set_rptr_offs)
{
		shortfreq_t offs;

		Tcl_GetLongFromObj(interp, objv[2], &offs);
		return rig_set_rptr_offs(rig, RIG_VFO_CURR, offs);
}


declare_proto_rig(get_rptr_offs)
{
		int status;
		shortfreq_t offs;
		Tcl_Obj *resultPtr;

		resultPtr = Tcl_GetObjResult(interp);

		status = rig_get_rptr_offs(rig, RIG_VFO_CURR, &offs);
		if (status != RIG_OK)
				return status;

		Tcl_SetLongObj(resultPtr, offs);
		return RIG_OK;
}

declare_proto_rig(set_rit)
{
		shortfreq_t rit;

		Tcl_GetLongFromObj(interp, objv[2], &rit);
		return rig_set_rit(rig, RIG_VFO_CURR, rit);
}


declare_proto_rig(get_rit)
{
		int status;
		shortfreq_t rit;
		Tcl_Obj *resultPtr;

		resultPtr = Tcl_GetObjResult(interp);

		status = rig_get_rit(rig, RIG_VFO_CURR, &rit);
		if (status != RIG_OK)
				return status;

		Tcl_SetLongObj(resultPtr, rit);
		return RIG_OK;
}

declare_proto_rig(set_xit)
{
		shortfreq_t xit;

		Tcl_GetLongFromObj(interp, objv[2], &xit);
		return rig_set_xit(rig, RIG_VFO_CURR, xit);
}


declare_proto_rig(get_xit)
{
		int status;
		shortfreq_t xit;
		Tcl_Obj *resultPtr;

		resultPtr = Tcl_GetObjResult(interp);

		status = rig_get_xit(rig, RIG_VFO_CURR, &xit);
		if (status != RIG_OK)
				return status;

		Tcl_SetLongObj(resultPtr, xit);
		return RIG_OK;
}


declare_proto_rig(set_ts)
{
		shortfreq_t ts;

		Tcl_GetLongFromObj(interp, objv[2], &ts);
		return rig_set_ts(rig, RIG_VFO_CURR, ts);
}


declare_proto_rig(get_ts)
{
		int status;
		shortfreq_t ts;
		Tcl_Obj *resultPtr;

		resultPtr = Tcl_GetObjResult(interp);

		status = rig_get_ts(rig, RIG_VFO_CURR, &ts);
		if (status != RIG_OK)
				return status;

		Tcl_SetLongObj(resultPtr, ts);
		return RIG_OK;
}

declare_proto_rig(set_dcs_code)
{
		tone_t code;

		Tcl_GetIntFromObj(interp, objv[2], &code);
		return rig_set_dcs_code(rig, RIG_VFO_CURR, code);
}


declare_proto_rig(get_dcs_code)
{
		int status;
		tone_t code;
		Tcl_Obj *resultPtr;

		resultPtr = Tcl_GetObjResult(interp);

		status = rig_get_dcs_code(rig, RIG_VFO_CURR, &code);
		if (status != RIG_OK)
				return status;

		Tcl_SetIntObj(resultPtr, code);
		return RIG_OK;
}

declare_proto_rig(set_dcs_sql)
{
		tone_t code;

		Tcl_GetIntFromObj(interp, objv[2], &code);
		return rig_set_dcs_sql(rig, RIG_VFO_CURR, code);
}


declare_proto_rig(get_dcs_sql)
{
		int status;
		tone_t code;
		Tcl_Obj *resultPtr;

		resultPtr = Tcl_GetObjResult(interp);

		status = rig_get_dcs_sql(rig, RIG_VFO_CURR, &code);
		if (status != RIG_OK)
				return status;

		Tcl_SetIntObj(resultPtr, code);
		return RIG_OK;
}


declare_proto_rig(set_ctcss_tone)
{
		tone_t code;

		Tcl_GetIntFromObj(interp, objv[2], &code);
		return rig_set_ctcss_tone(rig, RIG_VFO_CURR, code);
}


declare_proto_rig(get_ctcss_tone)
{
		int status;
		tone_t code;
		Tcl_Obj *resultPtr;

		resultPtr = Tcl_GetObjResult(interp);

		status = rig_get_ctcss_tone(rig, RIG_VFO_CURR, &code);
		if (status != RIG_OK)
				return status;

		Tcl_SetIntObj(resultPtr, code);
		return RIG_OK;
}

declare_proto_rig(set_ctcss_sql)
{
		tone_t code;

		Tcl_GetIntFromObj(interp, objv[2], &code);
		return rig_set_ctcss_sql(rig, RIG_VFO_CURR, code);
}


declare_proto_rig(get_ctcss_sql)
{
		int status;
		tone_t code;
		Tcl_Obj *resultPtr;

		resultPtr = Tcl_GetObjResult(interp);

		status = rig_get_ctcss_sql(rig, RIG_VFO_CURR, &code);
		if (status != RIG_OK)
				return status;

		Tcl_SetIntObj(resultPtr, code);
		return RIG_OK;
}


declare_proto_rig(get_info)
{
		const char *s;
		Tcl_Obj *resultPtr;

		resultPtr = Tcl_GetObjResult(interp);

		s = rig_get_info(rig);
		Tcl_SetStringObj(resultPtr, s ? s : "None", -1);

		return RIG_OK;
}


declare_proto_rig(set_func)
{
		int status;
		setting_t func;
		int stat;

		func = parse_func(Tcl_GetString(objv[2]));
		status = Tcl_GetIntFromObj(interp, objv[3], &stat);
		if (status != TCL_OK)
			return status;
		return rig_set_func(rig, RIG_VFO_CURR, func, stat);
}

declare_proto_rig(get_func)
{
		int status;
		setting_t func;
		int stat;
		Tcl_Obj *resultPtr;

		resultPtr = Tcl_GetObjResult(interp);

		func = parse_func(Tcl_GetString(objv[2]));
		status = rig_get_func(rig, RIG_VFO_CURR, func, &stat);
		if (status != RIG_OK)
				return status;

		Tcl_SetIntObj(resultPtr, stat);
		return RIG_OK;
}

declare_proto_rig(set_level)
{
		int status;
		setting_t level;
		value_t val;
		double d;

		level = parse_level(Tcl_GetString(objv[2]));
		if (RIG_LEVEL_IS_FLOAT(level)) {
			status = Tcl_GetDoubleFromObj(interp, objv[3], &d);
			val.f = d;
		} else {
			status = Tcl_GetIntFromObj(interp, objv[3], &val.i);
		}
		if (status != TCL_OK)
			return status;
		return rig_set_level(rig, RIG_VFO_CURR, level, val);
}

declare_proto_rig(get_level)
{
		int status;
		setting_t level;
		value_t val;
		double d;
		Tcl_Obj *resultPtr;

		resultPtr = Tcl_GetObjResult(interp);

		level = parse_level(Tcl_GetString(objv[2]));
		status = rig_get_level(rig, RIG_VFO_CURR, level, &val);
		if (status != RIG_OK)
				return status;

		if (RIG_LEVEL_IS_FLOAT(level)) {
			d = val.f;
			Tcl_SetDoubleObj(resultPtr, d);
		} else {
			Tcl_SetIntObj(resultPtr, val.i);
		}
		return RIG_OK;
}

declare_proto_rig(set_parm)
{
		int status;
		setting_t parm;
		value_t val;
		double d;

		parm = parse_parm(Tcl_GetString(objv[2]));
		if (RIG_PARM_IS_FLOAT(parm)) {
			status = Tcl_GetDoubleFromObj(interp, objv[3], &d);
			val.f = d;
		} else {
			status = Tcl_GetIntFromObj(interp, objv[3], &val.i);
		}
		if (status != TCL_OK)
			return status;
		return rig_set_parm(rig, parm, val);
}

declare_proto_rig(get_parm)
{
		int status;
		setting_t parm;
		value_t val;
		double d;
		Tcl_Obj *resultPtr;

		resultPtr = Tcl_GetObjResult(interp);

		parm = parse_parm(Tcl_GetString(objv[2]));
		status = rig_get_parm(rig, parm, &val);
		if (status != RIG_OK)
				return status;

		if (RIG_PARM_IS_FLOAT(parm)) {
			d = val.f;
			Tcl_SetDoubleObj(resultPtr, d);
		} else {
			Tcl_SetIntObj(resultPtr, val.i);
		}
		return RIG_OK;
}





#if 0

declare_proto_rig(set_ptt)
{
		ptt_t ptt;

		sscanf(arg1, "%d", (int*)&ptt);
		return rig_set_ptt(rig, RIG_VFO_CURR, ptt);
}


declare_proto_rig(get_ptt)
{
		int status;
		ptt_t ptt;

		status = rig_get_ptt(rig, RIG_VFO_CURR, &ptt);
		if (status != RIG_OK)
				return status;
		if (interactive)
			printf("%s: ", cmd->arg1);
		printf("%d\n", ptt);
		return status;
}


declare_proto_rig(set_rptr_shift)
{
		rptr_shift_t rptr_shift;

		rptr_shift = parse_rptr_shift(arg1);
		return rig_set_rptr_shift(rig, RIG_VFO_CURR, rptr_shift);
}


declare_proto_rig(get_rptr_shift)
{
		int status;
		rptr_shift_t rptr_shift;

		status = rig_get_rptr_shift(rig, RIG_VFO_CURR, &rptr_shift);
		if (status != RIG_OK)
				return status;
		if (interactive)
			printf("%s: ", cmd->arg1);
		printf("%s\n", strptrshift(rptr_shift));
		return status;
}


declare_proto_rig(set_rptr_offs)
{
		unsigned long rptr_offs;

		sscanf(arg1, "%ld", &rptr_offs);
		return rig_set_rptr_offs(rig, RIG_VFO_CURR, rptr_offs);
}


declare_proto_rig(get_rptr_offs)
{
		int status;
		unsigned long rptr_offs;

		status = rig_get_rptr_offs(rig, RIG_VFO_CURR, &rptr_offs);
		if (status != RIG_OK)
				return status;
		if (interactive)
			printf("%s: ", cmd->arg1);
		printf("%ld\n", rptr_offs);
		return status;
}


declare_proto_rig(set_ctcss_tone)
{
		tone_t tone;

		sscanf(arg1, "%d", &tone);
		return rig_set_ctcss_tone(rig, RIG_VFO_CURR, tone);
}


declare_proto_rig(get_ctcss_tone)
{
		int status;
		tone_t tone;

		status = rig_get_ctcss_tone(rig, RIG_VFO_CURR, &tone);
		if (status != RIG_OK)
				return status;
		if (interactive)
			printf("%s: ", cmd->arg1);
		printf("%d\n", tone);
		return status;
}


declare_proto_rig(set_dcs_code)
{
		tone_t code;

		sscanf(arg1, "%d", &code);
		return rig_set_dcs_code(rig, RIG_VFO_CURR, code);
}


declare_proto_rig(get_dcs_code)
{
		int status;
		tone_t code;

		status = rig_get_dcs_code(rig, RIG_VFO_CURR, &code);
		if (status != RIG_OK)
				return status;
		if (interactive)
			printf("%s: ", cmd->arg1);
		printf("%d\n", code);
		return status;
}


declare_proto_rig(set_split_freq)
{
		freq_t txfreq;

		sscanf(arg1, "%lld", &txfreq);
		return rig_set_split_freq(rig, RIG_VFO_CURR, txfreq);
}


declare_proto_rig(get_split_freq)
{
		int status;
		freq_t txfreq;

		status = rig_get_split_freq(rig, RIG_VFO_CURR, &txfreq);
		if (status != RIG_OK)
				return status;
		if (interactive)
			printf("%s: ", cmd->arg1);
		printf("%lld\n", txfreq);
		return status;
}

declare_proto_rig(set_split_mode)
{
		rmode_t mode;
		pbwidth_t width;

		mode = parse_mode(arg1);
		sscanf(arg2, "%d", (int*)&width);
		return rig_set_split_mode(rig, RIG_VFO_CURR, mode, width);
}


declare_proto_rig(get_split_mode)
{
		int status;
		rmode_t mode;
		pbwidth_t width;

		status = rig_get_split_mode(rig, RIG_VFO_CURR, &mode, &width);
		if (status != RIG_OK)
				return status;
		if (interactive)
			printf("%s: ", cmd->arg1);
		printf("%s\n", strrmode(mode));
		if (interactive)
			printf("%s: ", cmd->arg2);
		printf("%ld\n", width);
		return status;
}


declare_proto_rig(set_split)
{
		split_t split;

		sscanf(arg1, "%d", (int*)&split);
		return rig_set_split(rig, RIG_VFO_CURR, split);
}


declare_proto_rig(get_split)
{
		int status;
		split_t split;

		status = rig_get_split(rig, RIG_VFO_CURR, &split);
		if (status != RIG_OK)
				return status;
		if (interactive)
			printf("%s: ", cmd->arg1);
		printf("%d\n", split);
		return status;
}


declare_proto_rig(set_ts)
{
		unsigned long ts;

		sscanf(arg1, "%ld", &ts);
		return rig_set_ts(rig, RIG_VFO_CURR, ts);
}


declare_proto_rig(get_ts)
{
		int status;
		unsigned long ts;

		status = rig_get_ts(rig, RIG_VFO_CURR, &ts);
		if (status != RIG_OK)
				return status;
		if (interactive)
			printf("%s: ", cmd->arg1);
		printf("%ld\n", ts);
		return status;
}

declare_proto_rig(power2mW)
{
		int status;
		float power;
		freq_t freq;
		rmode_t mode;
		unsigned int mwp;

		printf("Power [0.0 .. 1.0]: ");
		scanf("%f", &power);
		printf("Frequency: ");
		scanf("%lld", &freq);
		printf("Mode: ");
		scanf("%d", &mode);
		status = rig_power2mW(rig, &mwp, power, freq, mode);
		printf("Power: %d mW\n", mwp);
		return status;
}


declare_proto_rig(set_level)
{
		setting_t level;
		value_t val;

		level = parse_level(arg1);
		if (RIG_LEVEL_IS_FLOAT(level))
			sscanf(arg2, "%f", &val.f);
		else
			sscanf(arg2, "%d", &val.i);

		return rig_set_level(rig, RIG_VFO_CURR, level, val);
}


declare_proto_rig(get_level)
{
		int status;
		setting_t level;
		value_t val;

		level = parse_level(arg1);
		status = rig_get_level(rig, RIG_VFO_CURR, level, &val);
		if (status != RIG_OK)
				return status;
		if (interactive)
			printf("%s: ", cmd->arg2);
		if (RIG_LEVEL_IS_FLOAT(level))
			printf("%f\n", val.f);
		else
			printf("%d\n", val.i);

		return status;
}


declare_proto_rig(set_func)
{
		setting_t func;
		int func_stat;

		func = parse_func(arg1);
		sscanf(arg2, "%d", (int*)&func_stat);
		return rig_set_func(rig, RIG_VFO_CURR, func, func_stat);
}


declare_proto_rig(get_func)
{
		int status;
		setting_t func;
		int func_stat;

		func = parse_func(arg1);
		status = rig_get_func(rig, RIG_VFO_CURR, func, &func_stat);
		if (status != RIG_OK)
				return status;
		if (interactive)
			printf("%s: ", cmd->arg2);
		printf("%d\n", func_stat);
		return status;
}

declare_proto_rig(set_parm)
{
		setting_t parm;
		value_t val;

		parm = parse_parm(arg1);
		if (RIG_PARM_IS_FLOAT(parm))
			sscanf(arg2, "%f", &val.f);
		else
			sscanf(arg2, "%d", &val.i);

		return rig_set_parm(rig, parm, val);
}


declare_proto_rig(get_parm)
{
		int status;
		setting_t parm;
		value_t val;

		parm = parse_parm(arg1);
		status = rig_get_parm(rig, parm, &val);
		if (status != RIG_OK)
				return status;
		if (interactive)
			printf("%s: ", cmd->arg2);
		if (RIG_PARM_IS_FLOAT(parm))
			printf("%f\n", val.f);
		else
			printf("%d\n", val.i);

		return status;
}


declare_proto_rig(set_bank)
{
		int bank;

		sscanf(arg1, "%d", &bank);
		return rig_set_bank(rig, RIG_VFO_CURR, bank);
}


declare_proto_rig(set_mem)
{
		int ch;

		sscanf(arg1, "%d", &ch);
		return rig_set_mem(rig, RIG_VFO_CURR, ch);
}


declare_proto_rig(get_mem)
{
		int status;
		int ch;

		status = rig_get_mem(rig, RIG_VFO_CURR, &ch);
		if (status != RIG_OK)
				return status;
		if (interactive)
			printf("%s: ", cmd->arg1);
		printf("%d\n", ch);
		return status;
}

declare_proto_rig(vfo_op)
{
		vfo_op_t op;

		op = parse_vfo_op(arg1);
		return rig_vfo_op(rig, RIG_VFO_CURR, op);
}

declare_proto_rig(scan)
{
		scan_t op;
		int ch;

		op = parse_scan(arg1);
		sscanf(arg2, "%d", &ch);
		return rig_scan(rig, RIG_VFO_CURR, op, ch);
}

declare_proto_rig(set_channel)
{
		fprintf(stderr,"rigctl_set_channel not implemented yet!\n");
		return -RIG_ENIMPL;
}


declare_proto_rig(get_channel)
{
		int status;
		channel_t chan;

		sscanf(arg1, "%d", &chan.channel_num);
		status = rig_get_channel(rig, &chan);
		if (status != RIG_OK)
				return status;
		/* TODO: dump data here */
		return status;
}


declare_proto_rig(set_trn)
{
		int trn;

		sscanf(arg1, "%d", &trn);
		return rig_set_trn(rig, trn);
}


declare_proto_rig(get_trn)
{
		int status;
		int trn;

		status = rig_get_trn(rig, &trn);
		if (status != RIG_OK)
				return status;
		if (interactive)
			printf("%s: ", cmd->arg1);
		printf("%d\n", trn);
		return status;
}
#endif