From 5b8cc94b012be67a861e2abcb3fcfe448bb681c0 Mon Sep 17 00:00:00 2001 From: George Baltz N3GB Date: Sun, 30 Jun 2024 14:31:39 -0400 Subject: [PATCH 1/4] More pointer conversions for rig->state. --- src/conf.c | 6 ++--- src/event.c | 29 +++++++++++---------- src/mem.c | 32 +++++++++++------------ src/network.c | 28 ++++++++++---------- src/serial.c | 2 +- src/settings.c | 69 ++++++++++++++++++++++++++------------------------ 6 files changed, 85 insertions(+), 81 deletions(-) diff --git a/src/conf.c b/src/conf.c index 26273ef58..8580f7e2a 100644 --- a/src/conf.c +++ b/src/conf.c @@ -42,7 +42,7 @@ /* - * Configuration options available in the rig->state struct. + * Configuration options available in the STATE(rig) struct. */ static const struct confparams frontend_cfg_params[] = { @@ -250,7 +250,7 @@ static int frontend_set_conf(RIG *rig, hamlib_token_t token, const char *val) long val_i; caps = rig->caps; - rs = &rig->state; + rs = STATE(rig); switch (token) { @@ -871,7 +871,7 @@ static int frontend_get_conf2(RIG *rig, hamlib_token_t token, char *val, int val hamlib_port_t *pttp = PTTPORT(rig); hamlib_port_t *dcdp = DCDPORT(rig); - rs = &rig->state; + rs = STATE(rig); switch (token) { diff --git a/src/event.c b/src/event.c index 5671be0a6..10a47ff88 100644 --- a/src/event.c +++ b/src/event.c @@ -50,7 +50,7 @@ #include "cache.h" #include "network.h" -#define CHECK_RIG_ARG(r) (!(r) || !(r)->caps || !(r)->state.comm_state) +#define CHECK_RIG_ARG(r) (!(r) || !(r)->caps || !STATE(r)->comm_state) #ifdef HAVE_PTHREAD typedef struct rig_poll_routine_args_s @@ -68,7 +68,7 @@ void *rig_poll_routine(void *arg) { rig_poll_routine_args *args = (rig_poll_routine_args *)arg; RIG *rig = args->rig; - struct rig_state *rs = &rig->state; + struct rig_state *rs = STATE(rig); struct rig_cache *cachep = CACHE(rig); int update_occurred; @@ -98,15 +98,15 @@ void *rig_poll_routine(void *arg) while (rs->poll_routine_thread_run) { - if (rig->state.current_vfo != vfo) + if (rs->current_vfo != vfo) { - vfo = rig->state.current_vfo; + vfo = rs->current_vfo; update_occurred = 1; } - if (rig->state.tx_vfo != tx_vfo) + if (rs->tx_vfo != tx_vfo) { - tx_vfo = rig->state.tx_vfo; + tx_vfo = rs->tx_vfo; update_occurred = 1; } @@ -266,7 +266,7 @@ void *rig_poll_routine(void *arg) */ int rig_poll_routine_start(RIG *rig) { - struct rig_state *rs = &rig->state; + struct rig_state *rs = STATE(rig); rig_poll_routine_priv_data *poll_routine_priv; ENTERFUNC; @@ -321,7 +321,7 @@ int rig_poll_routine_start(RIG *rig) */ int rig_poll_routine_stop(RIG *rig) { - struct rig_state *rs = &rig->state; + struct rig_state *rs = STATE(rig); rig_poll_routine_priv_data *poll_routine_priv; ENTERFUNC; @@ -614,6 +614,7 @@ int rig_fire_freq_event(RIG *rig, vfo_t vfo, freq_t freq) { ENTERFUNC; + struct rig_state *rs = STATE(rig); double dfreq = freq; rig_debug(RIG_DEBUG_TRACE, "Event: freq changed to %.0f Hz on %s\n", dfreq, rig_strvfo(vfo)); @@ -624,19 +625,19 @@ int rig_fire_freq_event(RIG *rig, vfo_t vfo, freq_t freq) // Should work for most other rigs using AI1; mode if (RIG_BACKEND_NUM(rig->caps->rig_model) != RIG_ICOM) { - rig->state.use_cached_freq = 1; + rs->use_cached_freq = 1; } - if (rig->state.freq_event_elapsed.tv_sec == 0) + if (rs->freq_event_elapsed.tv_sec == 0) { - elapsed_ms(&rig->state.freq_event_elapsed, HAMLIB_ELAPSED_SET); + elapsed_ms(&rs->freq_event_elapsed, HAMLIB_ELAPSED_SET); } - double e = elapsed_ms(&rig->state.freq_event_elapsed, HAMLIB_ELAPSED_GET); + double e = elapsed_ms(&rs->freq_event_elapsed, HAMLIB_ELAPSED_GET); if (e >= 250) // throttle events to 4 per sec { - elapsed_ms(&rig->state.freq_event_elapsed, HAMLIB_ELAPSED_SET); + elapsed_ms(&rs->freq_event_elapsed, HAMLIB_ELAPSED_SET); network_publish_rig_transceive_data(rig); if (rig->callbacks.freq_event) @@ -663,7 +664,7 @@ int rig_fire_mode_event(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) // Should work for most other rigs using AI1; mode if (RIG_BACKEND_NUM(rig->caps->rig_model) != RIG_ICOM) { - rig->state.use_cached_mode = 1; + STATE(rig)->use_cached_mode = 1; } network_publish_rig_transceive_data(rig); diff --git a/src/mem.c b/src/mem.c index 7f460eb33..3b3a64137 100644 --- a/src/mem.c +++ b/src/mem.c @@ -44,7 +44,7 @@ #ifndef DOC_HIDDEN -#define CHECK_RIG_ARG(r) (!(r) || !(r)->caps || !(r)->state.comm_state) +#define CHECK_RIG_ARG(r) (!(r) || !(r)->caps || !STATE(r)->comm_state) #endif /* !DOC_HIDDEN */ @@ -87,7 +87,7 @@ int HAMLIB_API rig_set_mem(RIG *rig, vfo_t vfo, int ch) if ((caps->targetable_vfo & RIG_TARGETABLE_MEM) || vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == STATE(rig)->current_vfo) { return caps->set_mem(rig, vfo, ch); } @@ -97,7 +97,7 @@ int HAMLIB_API rig_set_mem(RIG *rig, vfo_t vfo, int ch) return -RIG_ENTARGET; } - curr_vfo = rig->state.current_vfo; + curr_vfo = STATE(rig)->current_vfo; retcode = caps->set_vfo(rig, vfo); if (retcode != RIG_OK) @@ -150,7 +150,7 @@ int HAMLIB_API rig_get_mem(RIG *rig, vfo_t vfo, int *ch) if ((caps->targetable_vfo & RIG_TARGETABLE_MEM) || vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == STATE(rig)->current_vfo) { return caps->get_mem(rig, vfo, ch); } @@ -160,7 +160,7 @@ int HAMLIB_API rig_get_mem(RIG *rig, vfo_t vfo, int *ch) return -RIG_ENTARGET; } - curr_vfo = rig->state.current_vfo; + curr_vfo = STATE(rig)->current_vfo; retcode = caps->set_vfo(rig, vfo); if (retcode != RIG_OK) @@ -213,7 +213,7 @@ int HAMLIB_API rig_set_bank(RIG *rig, vfo_t vfo, int bank) if ((caps->targetable_vfo & RIG_TARGETABLE_BANK) || vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == STATE(rig)->current_vfo) { return caps->set_bank(rig, vfo, bank); } @@ -223,7 +223,7 @@ int HAMLIB_API rig_set_bank(RIG *rig, vfo_t vfo, int bank) return -RIG_ENTARGET; } - curr_vfo = rig->state.current_vfo; + curr_vfo = STATE(rig)->current_vfo; retcode = caps->set_vfo(rig, vfo); if (retcode != RIG_OK) @@ -727,7 +727,7 @@ int HAMLIB_API rig_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan) } can_emulate_by_vfo_mem = rc->set_vfo - && ((rig->state.vfo_list & RIG_VFO_MEM) == RIG_VFO_MEM); + && ((STATE(rig)->vfo_list & RIG_VFO_MEM) == RIG_VFO_MEM); can_emulate_by_vfo_op = rc->vfo_op && rig_has_vfo_op(rig, RIG_OP_FROM_VFO); @@ -737,7 +737,7 @@ int HAMLIB_API rig_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan) return -RIG_ENTARGET; } - curr_vfo = rig->state.current_vfo; + curr_vfo = STATE(rig)->current_vfo; if (vfotmp == RIG_VFO_MEM) { @@ -872,7 +872,7 @@ int HAMLIB_API rig_get_channel(RIG *rig, vfo_t vfox, channel_t *chan, } can_emulate_by_vfo_mem = rc->set_vfo - && ((rig->state.vfo_list & RIG_VFO_MEM) == RIG_VFO_MEM); + && ((STATE(rig)->vfo_list & RIG_VFO_MEM) == RIG_VFO_MEM); can_emulate_by_vfo_op = rc->vfo_op && rig_has_vfo_op(rig, RIG_OP_TO_VFO); @@ -882,7 +882,7 @@ int HAMLIB_API rig_get_channel(RIG *rig, vfo_t vfox, channel_t *chan, return -RIG_ENTARGET; } - curr_vfo = rig->state.current_vfo; + curr_vfo = STATE(rig)->current_vfo; if (vfotmp == RIG_VFO_MEM) { @@ -940,7 +940,7 @@ int get_chan_all_cb_generic(RIG *rig, vfo_t vfo, chan_cb_t chan_cb, rig_ptr_t arg) { int i, j; - chan_t *chan_list = rig->state.chan_list; + chan_t *chan_list = STATE(rig)->chan_list; channel_t *chan; for (i = 0; !RIG_IS_CHAN_END(chan_list[i]) && i < HAMLIB_CHANLSTSIZ; i++) @@ -1006,7 +1006,7 @@ int set_chan_all_cb_generic(RIG *rig, vfo_t vfo, chan_cb_t chan_cb, rig_ptr_t arg) { int i, j, retval; - chan_t *chan_list = rig->state.chan_list; + chan_t *chan_list = STATE(rig)->chan_list; channel_t *chan; for (i = 0; !RIG_IS_CHAN_END(chan_list[i]) && i < HAMLIB_CHANLSTSIZ; i++) @@ -1600,7 +1600,7 @@ const chan_t *HAMLIB_API rig_lookup_mem_caps(RIG *rig, int ch) if (ch == RIG_MEM_CAPS_ALL) { memset(&chan_list_all, 0, sizeof(chan_list_all)); - chan_list = rig->state.chan_list; + chan_list = STATE(rig)->chan_list; chan_list_all.startc = chan_list[0].startc; chan_list_all.type = RIG_MTYPE_NONE; /* meaningless */ @@ -1626,7 +1626,7 @@ const chan_t *HAMLIB_API rig_lookup_mem_caps(RIG *rig, int ch) return &chan_list_all; } - chan_list = rig->state.chan_list; + chan_list = STATE(rig)->chan_list; for (i = 0; i < HAMLIB_CHANLSTSIZ && !RIG_IS_CHAN_END(chan_list[i]); i++) { @@ -1661,7 +1661,7 @@ int HAMLIB_API rig_mem_count(RIG *rig) return -RIG_EINVAL; } - chan_list = rig->state.chan_list; + chan_list = STATE(rig)->chan_list; count = 0; for (i = 0; i < HAMLIB_CHANLSTSIZ && !RIG_IS_CHAN_END(chan_list[i]); i++) diff --git a/src/network.c b/src/network.c index 417f44dc1..87c07cad8 100644 --- a/src/network.c +++ b/src/network.c @@ -219,9 +219,9 @@ int network_init() } /** - * \brief Open network port using rig.state data + * \brief Open network port using STATE(rig) data * - * Open Open network port using rig.state data. + * Open network port using STATE(rig) data. * NB: The signal PIPE will be ignored for the whole application. * * \param rp Port data structure (must spec port id eg hostname:port) @@ -781,7 +781,7 @@ retry: static void multicast_publisher_write_lock(RIG *rig) { - struct rig_state *rs = &rig->state; + struct rig_state *rs = STATE(rig); multicast_publisher_priv_data *priv_data = (multicast_publisher_priv_data *) rs->multicast_publisher_priv_data; pthread_mutex_lock(&priv_data->args.write_lock); @@ -789,7 +789,7 @@ static void multicast_publisher_write_lock(RIG *rig) static void multicast_publisher_write_unlock(RIG *rig) { - struct rig_state *rs = &rig->state; + struct rig_state *rs = STATE(rig); multicast_publisher_priv_data *priv_data = (multicast_publisher_priv_data *) rs->multicast_publisher_priv_data; pthread_mutex_unlock(&priv_data->args.write_lock); @@ -798,7 +798,7 @@ static void multicast_publisher_write_unlock(RIG *rig) static int multicast_publisher_write_packet_header(RIG *rig, multicast_publisher_data_packet *packet) { - struct rig_state *rs = &rig->state; + struct rig_state *rs = STATE(rig); multicast_publisher_priv_data *mcast_publisher_priv; multicast_publisher_args *mcast_publisher_args; ssize_t result; @@ -828,7 +828,7 @@ static int multicast_publisher_write_packet_header(RIG *rig, // cppcheck-suppress unusedFunction int network_publish_rig_poll_data(RIG *rig) { - const struct rig_state *rs = &rig->state; + const struct rig_state *rs = STATE(rig); int result; multicast_publisher_data_packet packet = { @@ -852,7 +852,7 @@ int network_publish_rig_poll_data(RIG *rig) // cppcheck-suppress unusedFunction int network_publish_rig_transceive_data(RIG *rig) { - const struct rig_state *rs = &rig->state; + const struct rig_state *rs = STATE(rig); int result; multicast_publisher_data_packet packet = { @@ -876,7 +876,7 @@ int network_publish_rig_transceive_data(RIG *rig) int network_publish_rig_spectrum_data(RIG *rig, struct rig_spectrum_line *line) { int result; - struct rig_state *rs = &rig->state; + struct rig_state *rs = STATE(rig); multicast_publisher_priv_data *mcast_publisher_priv; multicast_publisher_args *mcast_publisher_args; multicast_publisher_data_packet packet = @@ -1006,7 +1006,7 @@ void *multicast_publisher(void *arg) struct multicast_publisher_args_s *args = (struct multicast_publisher_args_s *) arg; RIG *rig = args->rig; - struct rig_state *rs = &rig->state; + struct rig_state *rs = STATE(rig); struct rig_spectrum_line spectrum_line; uint8_t packet_type = MULTICAST_PUBLISHER_DATA_PACKET_TYPE_SPECTRUM; multicast_publisher_priv_data *mcast_publisher_priv = @@ -1348,7 +1348,7 @@ void *multicast_receiver(void *arg) struct multicast_receiver_args_s *args = (struct multicast_receiver_args_s *) arg; RIG *rig = args->rig; - struct rig_state *rs = &rig->state; + struct rig_state *rs = STATE(rig); multicast_receiver_priv_data *mcast_receiver_priv = (multicast_receiver_priv_data *) rs->multicast_receiver_priv_data; @@ -1572,7 +1572,7 @@ void *multicast_receiver(void *arg) int network_multicast_publisher_start(RIG *rig, const char *multicast_addr, int multicast_port, enum multicast_item_e items) { - struct rig_state *rs = &rig->state; + struct rig_state *rs = STATE(rig); multicast_publisher_priv_data *mcast_publisher_priv; int socket_fd; int status; @@ -1729,7 +1729,7 @@ int network_multicast_publisher_start(RIG *rig, const char *multicast_addr, */ int network_multicast_publisher_stop(RIG *rig) { - struct rig_state *rs = &rig->state; + struct rig_state *rs = STATE(rig); multicast_publisher_priv_data *mcast_publisher_priv; ENTERFUNC; @@ -1787,7 +1787,7 @@ int network_multicast_publisher_stop(RIG *rig) int network_multicast_receiver_start(RIG *rig, const char *multicast_addr, int multicast_port) { - struct rig_state *rs = &rig->state; + struct rig_state *rs = STATE(rig); multicast_receiver_priv_data *mcast_receiver_priv; int socket_fd; int status; @@ -1897,7 +1897,7 @@ int network_multicast_receiver_start(RIG *rig, const char *multicast_addr, */ int network_multicast_receiver_stop(RIG *rig) { - struct rig_state *rs = &rig->state; + struct rig_state *rs = STATE(rig); multicast_receiver_priv_data *mcast_receiver_priv; ENTERFUNC; diff --git a/src/serial.c b/src/serial.c index 302e67b0c..7ed9ff65d 100644 --- a/src/serial.c +++ b/src/serial.c @@ -128,7 +128,7 @@ int is_uh_radio_fd(int fd) /** - * \brief Open serial port using rig.state data + * \brief Open serial port using STATE(rig) data * \param rp port data structure (must spec port id eg /dev/ttyS1) * \return RIG_OK or < 0 if error */ diff --git a/src/settings.c b/src/settings.c index eea32a176..8dfbb6731 100644 --- a/src/settings.c +++ b/src/settings.c @@ -48,7 +48,7 @@ #ifndef DOC_HIDDEN -# define CHECK_RIG_ARG(r) (!(r) || !(r)->caps || !(r)->state.comm_state) +# define CHECK_RIG_ARG(r) (!(r) || !(r)->caps || !STATE(r)->comm_state) #endif /* !DOC_HIDDEN */ @@ -92,7 +92,7 @@ int HAMLIB_API rig_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) if ((caps->targetable_vfo & RIG_TARGETABLE_LEVEL) || vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == STATE(rig)->current_vfo) { #if defined(HAVE_PTHREAD) @@ -112,7 +112,7 @@ int HAMLIB_API rig_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) return -RIG_ENTARGET; } - curr_vfo = rig->state.current_vfo; + curr_vfo = STATE(rig)->current_vfo; retcode = caps->set_vfo(rig, vfo); if (retcode != RIG_OK) @@ -153,6 +153,7 @@ int HAMLIB_API rig_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) int HAMLIB_API rig_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) { const struct rig_caps *caps; + struct rig_state *rs = STATE(rig); int retcode; vfo_t curr_vfo; @@ -177,7 +178,7 @@ int HAMLIB_API rig_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) if (level == RIG_LEVEL_STRENGTH && (caps->has_get_level & RIG_LEVEL_STRENGTH) == 0 && rig_has_get_level(rig, RIG_LEVEL_RAWSTR) - && rig->state.str_cal.size) + && rs->str_cal.size) { value_t rawstr; @@ -189,14 +190,14 @@ int HAMLIB_API rig_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) return retcode; } - val->i = (int)rig_raw2val(rawstr.i, &rig->state.str_cal); + val->i = (int)rig_raw2val(rawstr.i, &rs->str_cal); return RIG_OK; } if ((caps->targetable_vfo & RIG_TARGETABLE_LEVEL) || vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == rs->current_vfo) { return caps->get_level(rig, vfo, level, val); @@ -207,7 +208,7 @@ int HAMLIB_API rig_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) return -RIG_ENTARGET; } - curr_vfo = rig->state.current_vfo; + curr_vfo = rs->current_vfo; retcode = caps->set_vfo(rig, vfo); if (retcode != RIG_OK) @@ -315,7 +316,7 @@ setting_t HAMLIB_API rig_has_get_level(RIG *rig, setting_t level) return 0; } - return (rig->state.has_get_level & level); + return (STATE(rig)->has_get_level & level); } @@ -345,7 +346,7 @@ setting_t HAMLIB_API rig_has_set_level(RIG *rig, setting_t level) return 0; } - return (rig->state.has_set_level & level); + return (STATE(rig)->has_set_level & level); } @@ -374,7 +375,7 @@ setting_t HAMLIB_API rig_has_get_parm(RIG *rig, setting_t parm) return 0; } - return (rig->state.has_get_parm & parm); + return (STATE(rig)->has_get_parm & parm); } @@ -403,7 +404,7 @@ setting_t HAMLIB_API rig_has_set_parm(RIG *rig, setting_t parm) return 0; } - return (rig->state.has_set_parm & parm); + return (STATE(rig)->has_set_parm & parm); } @@ -433,7 +434,7 @@ setting_t HAMLIB_API rig_has_get_func(RIG *rig, setting_t func) return 0; } - return (rig->state.has_get_func & func); + return (STATE(rig)->has_get_func & func); } @@ -462,7 +463,7 @@ setting_t HAMLIB_API rig_has_set_func(RIG *rig, setting_t func) return 0; } - return (rig->state.has_set_func & func); + return (STATE(rig)->has_set_func & func); } @@ -487,6 +488,7 @@ setting_t HAMLIB_API rig_has_set_func(RIG *rig, setting_t func) int HAMLIB_API rig_set_func(RIG *rig, vfo_t vfo, setting_t func, int status) { const struct rig_caps *caps; + struct rig_state *rs = STATE(rig); int retcode; vfo_t curr_vfo; @@ -500,36 +502,36 @@ int HAMLIB_API rig_set_func(RIG *rig, vfo_t vfo, setting_t func, int status) caps = rig->caps; if ((caps->set_func == NULL || !rig_has_set_func(rig, func)) - && access(rig->state.tuner_control_pathname, X_OK) == -1) + && access(rs->tuner_control_pathname, X_OK) == -1) { return -RIG_ENAVAIL; } - if (access(rig->state.tuner_control_pathname, X_OK) != -1) + if (access(rs->tuner_control_pathname, X_OK) != -1) { char cmd[1024]; - snprintf(cmd, sizeof(cmd), "%s %d", rig->state.tuner_control_pathname, status); + snprintf(cmd, sizeof(cmd), "%s %d", rs->tuner_control_pathname, status); rig_debug(RIG_DEBUG_TRACE, "%s: Calling external script '%s'\n", __func__, - rig->state.tuner_control_pathname); + rs->tuner_control_pathname); retcode = system(cmd); - if (retcode != 0) { rig_debug(RIG_DEBUG_ERR, "%s: executing %s failed\n", __func__, rig->state.tuner_control_pathname); } + if (retcode != 0) { rig_debug(RIG_DEBUG_ERR, "%s: executing %s failed\n", __func__, rs->tuner_control_pathname); } return (retcode == 0 ? RIG_OK : -RIG_ERJCTED); } else { - if (strcmp(rig->state.tuner_control_pathname, "hamlib_tuner_control")) + if (strcmp(rs->tuner_control_pathname, "hamlib_tuner_control")) { rig_debug(RIG_DEBUG_ERR, "%s: unable to find '%s'\n", __func__, - rig->state.tuner_control_pathname); + rs->tuner_control_pathname); return -RIG_EINVAL; } } if ((caps->targetable_vfo & RIG_TARGETABLE_FUNC) || vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == rs->current_vfo) { return caps->set_func(rig, vfo, func, status); @@ -538,7 +540,7 @@ int HAMLIB_API rig_set_func(RIG *rig, vfo_t vfo, setting_t func, int status) { int targetable = caps->targetable_vfo & RIG_TARGETABLE_FUNC; rig_debug(RIG_DEBUG_TRACE, "%s: targetable=%d, vfo=%s, currvfo=%s\n", __func__, - targetable, rig_strvfo(vfo), rig_strvfo(rig->state.current_vfo)); + targetable, rig_strvfo(vfo), rig_strvfo(rs->current_vfo)); } if (!caps->set_vfo) @@ -546,7 +548,7 @@ int HAMLIB_API rig_set_func(RIG *rig, vfo_t vfo, setting_t func, int status) return -RIG_ENTARGET; } - curr_vfo = rig->state.current_vfo; + curr_vfo = rs->current_vfo; retcode = caps->set_vfo(rig, vfo); if (retcode != RIG_OK) @@ -583,6 +585,7 @@ int HAMLIB_API rig_set_func(RIG *rig, vfo_t vfo, setting_t func, int status) int HAMLIB_API rig_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status) { const struct rig_caps *caps; + struct rig_state *rs = STATE(rig); int retcode; vfo_t curr_vfo; @@ -603,7 +606,7 @@ int HAMLIB_API rig_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status) if ((caps->targetable_vfo & RIG_TARGETABLE_FUNC) || vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == rs->current_vfo) { return caps->get_func(rig, vfo, func, status); @@ -614,7 +617,7 @@ int HAMLIB_API rig_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status) return -RIG_ENTARGET; } - curr_vfo = rig->state.current_vfo; + curr_vfo = rs->current_vfo; retcode = caps->set_vfo(rig, vfo); if (retcode != RIG_OK) @@ -669,7 +672,7 @@ int HAMLIB_API rig_set_ext_level(RIG *rig, if ((caps->targetable_vfo & RIG_TARGETABLE_LEVEL) || vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == STATE(rig)->current_vfo) { return caps->set_ext_level(rig, vfo, token, val); @@ -680,7 +683,7 @@ int HAMLIB_API rig_set_ext_level(RIG *rig, return -RIG_ENTARGET; } - curr_vfo = rig->state.current_vfo; + curr_vfo = STATE(rig)->current_vfo; retcode = caps->set_vfo(rig, vfo); if (retcode != RIG_OK) @@ -735,7 +738,7 @@ int HAMLIB_API rig_get_ext_level(RIG *rig, if ((caps->targetable_vfo & RIG_TARGETABLE_LEVEL) || vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == STATE(rig)->current_vfo) { return caps->get_ext_level(rig, vfo, token, val); @@ -746,7 +749,7 @@ int HAMLIB_API rig_get_ext_level(RIG *rig, return -RIG_ENTARGET; } - curr_vfo = rig->state.current_vfo; + curr_vfo = STATE(rig)->current_vfo; retcode = caps->set_vfo(rig, vfo); if (retcode != RIG_OK) @@ -800,7 +803,7 @@ int HAMLIB_API rig_set_ext_func(RIG *rig, if ((caps->targetable_vfo & RIG_TARGETABLE_FUNC) || vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == STATE(rig)->current_vfo) { return caps->set_ext_func(rig, vfo, token, status); @@ -811,7 +814,7 @@ int HAMLIB_API rig_set_ext_func(RIG *rig, return -RIG_ENTARGET; } - curr_vfo = rig->state.current_vfo; + curr_vfo = STATE(rig)->current_vfo; retcode = caps->set_vfo(rig, vfo); if (retcode != RIG_OK) @@ -866,7 +869,7 @@ int HAMLIB_API rig_get_ext_func(RIG *rig, if ((caps->targetable_vfo & RIG_TARGETABLE_FUNC) || vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == STATE(rig)->current_vfo) { return caps->get_ext_func(rig, vfo, token, status); @@ -877,7 +880,7 @@ int HAMLIB_API rig_get_ext_func(RIG *rig, return -RIG_ENTARGET; } - curr_vfo = rig->state.current_vfo; + curr_vfo = STATE(rig)->current_vfo; retcode = caps->set_vfo(rig, vfo); if (retcode != RIG_OK) From 00bc700ec18020e477dd025d7ef65d7c73e63279 Mon Sep 17 00:00:00 2001 From: George Baltz N3GB Date: Sun, 30 Jun 2024 16:41:00 -0400 Subject: [PATCH 2/4] More pointerizations in src/* --- src/cache.c | 33 ++++++------ src/misc.h | 30 +++++------ src/multicast.c | 119 ++++++++++++++++++++++++-------------------- src/snapshot_data.c | 19 ++++--- src/tones.c | 42 +++++++++------- 5 files changed, 134 insertions(+), 109 deletions(-) diff --git a/src/cache.c b/src/cache.c index 4811fc3b2..cac9c6ae8 100644 --- a/src/cache.c +++ b/src/cache.c @@ -24,7 +24,7 @@ #include "cache.h" #include "misc.h" -#define CHECK_RIG_ARG(r) (!(r) || !(r)->caps || !(r)->state.comm_state) +#define CHECK_RIG_ARG(r) (!(r) || !(r)->caps || !STATE(r)->comm_state) /** * \file cache.c @@ -35,6 +35,7 @@ int rig_set_cache_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) { struct rig_cache *cachep = CACHE(rig); + struct rig_state *rs = STATE(rig); ENTERFUNC; @@ -43,16 +44,16 @@ int rig_set_cache_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) if (vfo == RIG_VFO_CURR) { // if CURR then update this before we figure out the real VFO - vfo = rig->state.current_vfo; + vfo = rs->current_vfo; } else if (vfo == RIG_VFO_TX) { - vfo = rig->state.tx_vfo; + vfo = rs->tx_vfo; rig_debug(RIG_DEBUG_VERBOSE, "%s: TX VFO = %s\n", __func__, rig_strvfo(vfo)); } else if (vfo == RIG_VFO_RX) { - vfo = rig->state.rx_vfo; + vfo = rs->rx_vfo; rig_debug(RIG_DEBUG_VERBOSE, "%s: RX VFO = %s\n", __func__, rig_strvfo(vfo)); } @@ -63,7 +64,7 @@ int rig_set_cache_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) if (vfo == RIG_VFO_OTHER) { vfo = vfo_fixup(rig, vfo, cachep->split); } - if (vfo == rig->state.current_vfo) + if (vfo == rs->current_vfo) { cachep->modeCurr = mode; if (width > 0) @@ -157,6 +158,7 @@ int rig_set_cache_freq(RIG *rig, vfo_t vfo, freq_t freq) { int flag = HAMLIB_ELAPSED_SET; struct rig_cache *cachep = CACHE(rig); + struct rig_state *rs = STATE(rig); if (rig_need_debug(RIG_DEBUG_CACHE)) { @@ -165,12 +167,12 @@ int rig_set_cache_freq(RIG *rig, vfo_t vfo, freq_t freq) rig_debug(RIG_DEBUG_CACHE, "%s(%d): vfo=%s, current_vfo=%s\n", __func__, __LINE__, - rig_strvfo(vfo), rig_strvfo(rig->state.current_vfo)); + rig_strvfo(vfo), rig_strvfo(rs->current_vfo)); if (vfo == RIG_VFO_CURR) { // if CURR then update this before we figure out the real VFO - vfo = rig->state.current_vfo; + vfo = rs->current_vfo; } // if freq == 0 then we are asking to invalidate the cache @@ -188,7 +190,7 @@ int rig_set_cache_freq(RIG *rig, vfo_t vfo, freq_t freq) rig_strvfo(vfo), freq); } - if (vfo == rig->state.current_vfo) + if (vfo == rs->current_vfo) { cachep->freqCurr = freq; elapsed_ms(&cachep->time_freqCurr, flag); @@ -307,6 +309,7 @@ int rig_get_cache(RIG *rig, vfo_t vfo, freq_t *freq, int *cache_ms_freq, rmode_t *mode, int *cache_ms_mode, pbwidth_t *width, int *cache_ms_width) { struct rig_cache *cachep = CACHE(rig); + struct rig_state *rs = STATE(rig); if (CHECK_RIG_ARG(rig) || !freq || !cache_ms_freq || !mode || !cache_ms_mode || !width || !cache_ms_width) @@ -321,25 +324,25 @@ int rig_get_cache(RIG *rig, vfo_t vfo, freq_t *freq, int *cache_ms_freq, rig_debug(RIG_DEBUG_CACHE, "%s(%d): vfo=%s, current_vfo=%s\n", __func__, __LINE__, - rig_strvfo(vfo), rig_strvfo(rig->state.current_vfo)); + rig_strvfo(vfo), rig_strvfo(rs->current_vfo)); if (vfo == RIG_VFO_CURR) { - vfo = rig->state.current_vfo; + vfo = rs->current_vfo; } else if (vfo == RIG_VFO_TX) { - vfo = rig->state.tx_vfo; + vfo = rs->tx_vfo; rig_debug(RIG_DEBUG_VERBOSE, "%s: TX VFO = %s\n", __func__, rig_strvfo(vfo)); } else if (vfo == RIG_VFO_RX) { - vfo = rig->state.rx_vfo; + vfo = rs->rx_vfo; rig_debug(RIG_DEBUG_VERBOSE, "%s: RX VFO = %s\n", __func__, rig_strvfo(vfo)); } else if (vfo == RIG_VFO_OTHER) { - switch (rig->state.current_vfo) + switch (rs->current_vfo) { case RIG_VFO_CURR: break; // no change @@ -384,7 +387,7 @@ int rig_get_cache(RIG *rig, vfo_t vfo, freq_t *freq, int *cache_ms_freq, default: rig_debug(RIG_DEBUG_WARN, "%s(%d): unknown vfo=%s, curr_vfo=%s\n", __func__, __LINE__, - rig_strvfo(vfo), rig_strvfo(rig->state.current_vfo)); + rig_strvfo(vfo), rig_strvfo(rs->current_vfo)); } } @@ -574,7 +577,7 @@ void rig_cache_show(RIG *rig, const char *func, int line) cachep->freqMainB, rig_strrmode(cachep->modeMainB), (int)cachep->widthMainB); - if (rig->state.vfo_list & RIG_VFO_SUB_A) + if (STATE(rig)->vfo_list & RIG_VFO_SUB_A) { rig_debug(RIG_DEBUG_CACHE, "%s(%d): freqSubA=%.0f, modeSubA=%s, widthSubA=%d\n", func, line, diff --git a/src/misc.h b/src/misc.h index 18a2050cc..31ff966ec 100644 --- a/src/misc.h +++ b/src/misc.h @@ -30,11 +30,11 @@ */ #ifdef HAVE_PTHREAD #include -#define set_transaction_active(rig) {pthread_mutex_lock(&rig->state.mutex_set_transaction);(rig)->state.transaction_active = 1;} -#define set_transaction_inactive(rig) {(rig)->state.transaction_active = 0;pthread_mutex_unlock(&rig->state.mutex_set_transaction);} +#define set_transaction_active(rig) {pthread_mutex_lock(&STATE(rig)->mutex_set_transaction);STATE(rig)->transaction_active = 1;} +#define set_transaction_inactive(rig) {STATE(rig)->transaction_active = 0;pthread_mutex_unlock(&STATE(rig)->mutex_set_transaction);} #else -#define set_transaction_active(rig) {(rig)->state.transaction_active = 1;} -#define set_transaction_inactive(rig) {(rig)->state.transaction_active = 0;} +#define set_transaction_active(rig) {STATE(rig)->transaction_active = 1;} +#define set_transaction_inactive(rig) {STATE(rig)->transaction_active = 0;} #endif __BEGIN_DECLS @@ -157,24 +157,24 @@ extern HAMLIB_EXPORT(char *)date_strget(char *buf, int buflen, int localtime); #define __FILENAME__ (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__) void errmsg(int err, char *s, const char *func, const char *file, int line); #define ERRMSG(err, s) errmsg(err, s, __func__, __FILENAME__, __LINE__) -#define ENTERFUNC { ++rig->state.depth; \ - rig_debug(RIG_DEBUG_VERBOSE, "%s%d:%s(%d):%s entered\n", spaces(rig->state.depth), rig->state.depth, __FILENAME__, __LINE__, __func__); \ +#define ENTERFUNC { ++STATE(rig)->depth; \ + rig_debug(RIG_DEBUG_VERBOSE, "%s%d:%s(%d):%s entered\n", spaces(STATE(rig)->depth), STATE(rig)->depth, __FILENAME__, __LINE__, __func__); \ } #define ENTERFUNC2 { rig_debug(RIG_DEBUG_VERBOSE, "%s(%d):%s entered\n", __FILENAME__, __LINE__, __func__); \ } // we need to refer to rc just once as it // could be a function call #define RETURNFUNC(rc) {do { \ - int rctmp = rc; \ - rig_debug(RIG_DEBUG_VERBOSE, "%s%d:%s(%d):%s returning(%ld) %s\n", spaces(rig->state.depth), rig->state.depth, __FILENAME__, __LINE__, __func__, (long int) (rctmp), rctmp<0?rigerror2(rctmp):""); \ - --rig->state.depth; \ - return (rctmp); \ - } while(0);} + int rctmp = rc; \ + rig_debug(RIG_DEBUG_VERBOSE, "%s%d:%s(%d):%s returning(%ld) %s\n", spaces(STATE(rig)->depth), STATE(rig)->depth, __FILENAME__, __LINE__, __func__, (long int) (rctmp), rctmp<0?rigerror2(rctmp):""); \ + --STATE(rig)->depth; \ + return (rctmp); \ + } while(0);} #define RETURNFUNC2(rc) {do { \ - int rctmp = rc; \ - rig_debug(RIG_DEBUG_VERBOSE, "%s(%d):%s returning2(%ld) %s\n", __FILENAME__, __LINE__, __func__, (long int) (rctmp), rctmp<0?rigerror2(rctmp):""); \ - return (rctmp); \ - } while(0);} + int rctmp = rc; \ + rig_debug(RIG_DEBUG_VERBOSE, "%s(%d):%s returning2(%ld) %s\n", __FILENAME__, __LINE__, __func__, (long int) (rctmp), rctmp<0?rigerror2(rctmp):""); \ + return (rctmp); \ + } while(0);} #define CACHE_RESET {\ elapsed_ms(&CACHE(rig)->time_freqMainA, HAMLIB_ELAPSED_INVALIDATE);\ diff --git a/src/multicast.c b/src/multicast.c index 8570f279c..68cdd4803 100644 --- a/src/multicast.c +++ b/src/multicast.c @@ -33,9 +33,10 @@ static struct sockaddr_in dest_addr = {0}; int multicast_stop(RIG *rig) { - if (rig->state.multicast) { rig->state.multicast->runflag = 0; } + struct rig_state *rs = STATE(rig); + if (rs->multicast) { rs->multicast->runflag = 0; } - pthread_join(rig->state.multicast->threadid, NULL); + pthread_join(rs->multicast->threadid, NULL); return RIG_OK; } @@ -44,6 +45,7 @@ static int multicast_status_changed(RIG *rig) { int retval; struct rig_cache *cachep = CACHE(rig); + struct rig_state *rs = STATE(rig); #if 0 freq_t freq, freqsave = cachep->freqMainA; @@ -63,7 +65,7 @@ static int multicast_status_changed(RIG *rig) #if 0 - if (rig->state.multicast->seqnumber % 2 == 0 + if (rs->multicast->seqnumber % 2 == 0 && (retval = rig_get_mode(rig, RIG_VFO_A, &modeA, &widthA)) != RIG_OK) { rig_debug(RIG_DEBUG_ERR, "%s: rig_get_modeA:%s\n", __func__, rigerror(retval)); @@ -77,7 +79,7 @@ static int multicast_status_changed(RIG *rig) #if 0 - if (rig->state.multicast->seqnumber % 2 == 0 + if (rs->multicast->seqnumber % 2 == 0 && (rig->caps->targetable_vfo & RIG_TARGETABLE_MODE) && (retval = rig_get_mode(rig, RIG_VFO_B, &modeB, &widthB)) != RIG_OK) { @@ -94,14 +96,14 @@ static int multicast_status_changed(RIG *rig) #if 0 - if (rig->state.multicast->seqnumber % 2 == 0 + if (rs->multicast->seqnumber % 2 == 0 && (retval = rig_get_ptt(rig, RIG_VFO_CURR, &ptt)) != RIG_OK) if (ptt != pttsave) { return 1; } split_t split, splitsave = cachep->split; vfo_t txvfo; - if (rig->state.multicast->seqnumber % 2 == 0 + if (rs->multicast->seqnumber % 2 == 0 && (retval = rig_get_split_vfo(rig, RIG_VFO_CURR, &split, &txvfo)) != RIG_OK) if (split != splitsave) { return 1; } @@ -192,6 +194,7 @@ void json_add_time(char *msg, int addComma) void json_add_vfoA(RIG *rig, char *msg) { struct rig_cache *cachep = CACHE(rig); + struct rig_state *rs = STATE(rig); strcat(msg, "{\n"); json_add_string(msg, "Name", "VFOA", 1); @@ -211,15 +214,15 @@ void json_add_vfoA(RIG *rig, char *msg) #if 0 // not working quite yet // what about full duplex? rx_vfo would be in rx all the time? rig_debug(RIG_DEBUG_ERR, "%s: rx_vfo=%s, tx_vfo=%s, split=%d\n", __func__, - rig_strvfo(rig->state.rx_vfo), rig_strvfo(rig->state.tx_vfo), + rig_strvfo(rs->rx_vfo), rig_strvfo(rs->tx_vfo), cachep->split); printf("%s: rx_vfo=%s, tx_vfo=%s, split=%d\n", __func__, - rig_strvfo(rig->state.rx_vfo), rig_strvfo(rig->state.tx_vfo), + rig_strvfo(rs->rx_vfo), rig_strvfo(rs->tx_vfo), cachep->split); if (cachep->split) { - if (rig->state.tx_vfo && (RIG_VFO_B | RIG_VFO_MAIN_B)) + if (rs->tx_vfo && (RIG_VFO_B | RIG_VFO_MAIN_B)) { json_add_boolean(msg, "RX", !cachep->ptt, 1); json_add_boolean(msg, "TX", 0, 0); @@ -230,7 +233,7 @@ void json_add_vfoA(RIG *rig, char *msg) json_add_boolean(msg, "TX", cachep->ptt, 0); } } - else if (rig->state.current_vfo && (RIG_VFO_A | RIG_VFO_MAIN_A)) + else if (rs->current_vfo && (RIG_VFO_A | RIG_VFO_MAIN_A)) { json_add_boolean(msg, "RX", !cachep->ptt, 1); json_add_boolean(msg, "TX", cachep->ptt, 0); @@ -248,6 +251,7 @@ void json_add_vfoA(RIG *rig, char *msg) void json_add_vfoB(RIG *rig, char *msg) { struct rig_cache *cachep = CACHE(rig); + struct rig_state *rs = STATE(rig); strcat(msg, ",\n{\n"); json_add_string(msg, "Name", "VFOB", 1); @@ -266,9 +270,9 @@ void json_add_vfoB(RIG *rig, char *msg) #if 0 // not working yet - if (rig->state.rx_vfo != rig->state.tx_vfo && cachep->split) + if (rs->rx_vfo != rs->tx_vfo && cachep->split) { - if (rig->state.tx_vfo && (RIG_VFO_B | RIG_VFO_MAIN_B)) + if (rs->tx_vfo && (RIG_VFO_B | RIG_VFO_MAIN_B)) { json_add_boolean(msg, "RX", 0, 1); json_add_boolean(msg, "TX", cachep->ptt, 0); @@ -279,7 +283,7 @@ void json_add_vfoB(RIG *rig, char *msg) json_add_boolean(msg, "TX", 0, 0); } } - else if (rig->state.current_vfo && (RIG_VFO_A | RIG_VFO_MAIN_A)) + else if (rs->current_vfo && (RIG_VFO_A | RIG_VFO_MAIN_A)) { json_add_boolean(msg, "RX", !cachep->ptt, 1); json_add_boolean(msg, "TX", cachep->ptt, 0); @@ -300,7 +304,8 @@ static int multicast_send_json(RIG *rig) char msg[8192]; // could be pretty big char buf[4096]; struct rig_cache *cachep = CACHE(rig); - + struct rig_state *rs = STATE(rig); + // sprintf(msg,"%s:f=%.1f", date_strget(msg, (int)sizeof(msg), 0), f); msg[0] = 0; snprintf(buf, sizeof(buf), "%s:%s", rig->caps->model_name, @@ -308,11 +313,11 @@ static int multicast_send_json(RIG *rig) strcat(msg, "{\n"); json_add_string(msg, "ID", buf, 1); json_add_time(msg, 1); - json_add_int(msg, "Sequence", rig->state.multicast->seqnumber++, 1); - json_add_string(msg, "VFOCurr", rig_strvfo(rig->state.current_vfo), 1); + json_add_int(msg, "Sequence", rs->multicast->seqnumber++, 1); + json_add_string(msg, "VFOCurr", rig_strvfo(rs->current_vfo), 1); json_add_int(msg, "PTT", cachep->ptt, 1); json_add_int(msg, "Split", cachep->split, 1); - rig_sprintf_mode(buf, sizeof(buf), rig->state.mode_list); + rig_sprintf_mode(buf, sizeof(buf), rs->mode_list); json_add_string(msg, "ModeList", buf, 1); strcat(msg, "\"VFOs\": [\n"); json_add_vfoA(rig, msg); @@ -333,17 +338,18 @@ void *multicast_thread_rx(void *vrig) // int ret = 0; RIG *rig = (RIG *)vrig; hamlib_port_t port; - rig->state.rig_type = RIG_TYPE_TRANSCEIVER; - rig->state.ptt_type = RIG_PTT_RIG; - rig->state.port_type = RIG_PORT_UDP_NETWORK; + struct rig_state *rs = STATE(rig); + rs->rig_type = RIG_TYPE_TRANSCEIVER; + rs->ptt_type = RIG_PTT_RIG; + rs->port_type = RIG_PORT_UDP_NETWORK; strcpy(port.pathname, "127.0.0.1:4532"); //rig_debug(RIG_DEBUG_TRACE, "%s: started\n", __func__); #if 0 network_open(&port, 4532); #endif - //while (rig->state.multicast->runflag && ret >= 0) - while (rig->state.multicast->runflag) + //while (rs->multicast->runflag && ret >= 0) + while (rs->multicast->runflag) { #if 0 ret = read_string(RIGPORT(rig), (unsigned char *) buf, sizeof(buf), "\n", @@ -377,10 +383,11 @@ void *multicast_thread(void *vrig) mode_t modeB, modeBsave = 0; ptt_t ptt, pttsave = 0; struct rig_cache *cachep = CACHE(rig); + struct rig_state *rs = STATE(rig); - rig->state.multicast->runflag = 1; + rs->multicast->runflag = 1; - while (rig->state.multicast->runflag) + while (rs->multicast->runflag) { #if 0 @@ -470,7 +477,9 @@ static char *GetWinsockLastError(char *errorBuffer, DWORD errorBufferSize) int multicast_init(RIG *rig, char *addr, int port) { - if (rig->state.multicast && rig->state.multicast->multicast_running) { return RIG_OK; } + struct rig_state *rs = STATE(rig); + + if (rs->multicast && rs->multicast->multicast_running) { return RIG_OK; } #ifdef _WIN32 WSADATA wsaData; @@ -485,22 +494,22 @@ int multicast_init(RIG *rig, char *addr, int port) #endif - if (rig->state.multicast == NULL) + if (rs->multicast == NULL) { - rig->state.multicast = calloc(1, sizeof(struct multicast_s)); + rs->multicast = calloc(1, sizeof(struct multicast_s)); } - else if (rig->state.multicast->multicast_running) { return RIG_OK; } // we only need one port + else if (rs->multicast->multicast_running) { return RIG_OK; } // we only need one port - //rig->state.multicast->mreq = {0}; + //rs->multicast->mreq = {0}; if (addr == NULL) { addr = RIG_MULTICAST_ADDR; } if (port == 0) { port = RIG_MULTICAST_PORT; } // Create a UDP socket - rig->state.multicast->sock = socket(AF_INET, SOCK_DGRAM, 0); + rs->multicast->sock = socket(AF_INET, SOCK_DGRAM, 0); - if (rig->state.multicast->sock < 0) + if (rs->multicast->sock < 0) { #ifdef _WIN32 int err = WSAGetLastError(); @@ -515,7 +524,7 @@ int multicast_init(RIG *rig, char *addr, int port) // Set the SO_REUSEADDR option to allow multiple processes to use the same address int optval = 1; - if (setsockopt(rig->state.multicast->sock, SOL_SOCKET, SO_REUSEADDR, + if (setsockopt(rs->multicast->sock, SOL_SOCKET, SO_REUSEADDR, (char *)&optval, sizeof(optval)) < 0) { @@ -533,7 +542,7 @@ int multicast_init(RIG *rig, char *addr, int port) #if 0 - if (bind(rig->state.multicast->sock, (struct sockaddr *)&saddr, + if (bind(rs->multicast->sock, (struct sockaddr *)&saddr, sizeof(saddr)) < 0) { rig_debug(RIG_DEBUG_ERR, "%s: bind: %s\n", __func__, strerror(errno)); @@ -544,13 +553,13 @@ int multicast_init(RIG *rig, char *addr, int port) // Construct the multicast group address // struct ip_mreq mreq = {0}; - rig->state.multicast->mreq.imr_multiaddr.s_addr = inet_addr(addr); - rig->state.multicast->mreq.imr_interface.s_addr = htonl(INADDR_ANY); + rs->multicast->mreq.imr_multiaddr.s_addr = inet_addr(addr); + rs->multicast->mreq.imr_interface.s_addr = htonl(INADDR_ANY); // Set the multicast TTL (time-to-live) to limit the scope of the packets char ttl = 1; - if (setsockopt(rig->state.multicast->sock, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, + if (setsockopt(rs->multicast->sock, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl)) < 0) { rig_debug(RIG_DEBUG_ERR, "%s: setsockopt: %s\n", __func__, strerror(errno)); @@ -561,8 +570,8 @@ int multicast_init(RIG *rig, char *addr, int port) // look like we need to implement the client in a separate thread? // Join the multicast group - if (setsockopt(rig->state.multicast->sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, - (char *)&rig->state.multicast->mreq, sizeof(rig->state.multicast->mreq)) < 0) + if (setsockopt(rs->multicast->sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, + (char *)&rs->multicast->mreq, sizeof(rs->multicast->mreq)) < 0) { rig_debug(RIG_DEBUG_ERR, "%s: setsockopt: %s\n", __func__, strerror(errno)); //return -RIG_EIO; @@ -571,19 +580,19 @@ int multicast_init(RIG *rig, char *addr, int port) #endif // prime the dest_addr for the send routine - memset(&rig->state.multicast->dest_addr, 0, - sizeof(rig->state.multicast->dest_addr)); - rig->state.multicast->dest_addr.sin_family = AF_INET; - rig->state.multicast->dest_addr.sin_addr.s_addr = inet_addr(addr); - rig->state.multicast->dest_addr.sin_port = htons(port); + memset(&rs->multicast->dest_addr, 0, + sizeof(rs->multicast->dest_addr)); + rs->multicast->dest_addr.sin_family = AF_INET; + rs->multicast->dest_addr.sin_addr.s_addr = inet_addr(addr); + rs->multicast->dest_addr.sin_port = htons(port); #if 0 - rig->state.multicast->runflag = 1; - pthread_create(&rig->state.multicast->threadid, NULL, multicast_thread, + rs->multicast->runflag = 1; + pthread_create(&rs->multicast->threadid, NULL, multicast_thread, (void *)rig); - //printf("threadid=%ld\n", rig->state.multicast->threadid); - rig->state.multicast->multicast_running = 1; - pthread_create(&rig->state.multicast->threadid, NULL, multicast_thread_rx, + //printf("threadid=%ld\n", rs->multicast->threadid); + rs->multicast->multicast_running = 1; + pthread_create(&rs->multicast->threadid, NULL, multicast_thread_rx, (void *)rig); #endif return RIG_OK; @@ -592,17 +601,19 @@ int multicast_init(RIG *rig, char *addr, int port) // cppcheck-suppress unusedFunction void multicast_close(RIG *rig) { + struct rig_state *rs = STATE(rig); + // Leave the multicast group - if (setsockopt(rig->state.multicast->sock, IPPROTO_IP, - IP_DROP_MEMBERSHIP, (char *)&rig->state.multicast->mreq, - sizeof(rig->state.multicast->mreq)) < 0) + if (setsockopt(rs->multicast->sock, IPPROTO_IP, + IP_DROP_MEMBERSHIP, (char *)&rs->multicast->mreq, + sizeof(rs->multicast->mreq)) < 0) { rig_debug(RIG_DEBUG_ERR, "%s: setsockopt: %s\n", __func__, strerror(errno)); return; } // Close the socket - if (close(rig->state.multicast->sock)) + if (close(rs->multicast->sock)) { rig_debug(RIG_DEBUG_ERR, "%s: close: %s\n", __func__, strerror(errno)); } @@ -626,7 +637,7 @@ int multicast_send(RIG *rig, const char *msg, int msglen) // Send the message to the multicast group - ssize_t num_bytes = sendto(rig->state.multicast->sock, msg, msglen, 0, + ssize_t num_bytes = sendto(STATE(rig)->multicast->sock, msg, msglen, 0, (struct sockaddr *)&addr, sizeof(addr)); @@ -665,7 +676,7 @@ int main(int argc, const char *argv[]) RIGPORT(rig)->parm.serial.rate = 38400; rig_open(rig); multicast_init(rig, "224.0.0.1", 4532); - pthread_join(rig->state.multicast->threadid, NULL); + pthread_join(STATE(rig)->multicast->threadid, NULL); pthread_exit(NULL); return 0; } diff --git a/src/snapshot_data.c b/src/snapshot_data.c index ca5eca2eb..c68f13a90 100644 --- a/src/snapshot_data.c +++ b/src/snapshot_data.c @@ -20,16 +20,17 @@ static int snapshot_serialize_rig(cJSON *rig_node, RIG *rig) cJSON *node; char buf[1024]; struct rig_cache *cachep = CACHE(rig); + struct rig_state *rs = STATE(rig); cJSON *id_node = cJSON_CreateObject(); cJSON_AddStringToObject(id_node, "model", rig->caps->model_name); cJSON_AddStringToObject(id_node, "endpoint", RIGPORT(rig)->pathname); cJSON_AddStringToObject(id_node, "process", snapshot_data_pid); - cJSON_AddStringToObject(id_node, "deviceId", rig->state.device_id); + cJSON_AddStringToObject(id_node, "deviceId", rs->device_id); cJSON_AddItemToObject(rig_node, "id", id_node); node = cJSON_AddStringToObject(rig_node, "status", - rig_strcommstatus(rig->state.comm_status)); + rig_strcommstatus(rs->comm_status)); if (node == NULL) { @@ -75,7 +76,7 @@ static int snapshot_serialize_rig(cJSON *rig_node, RIG *rig) goto error; } - rig_sprintf_mode(buf, sizeof(buf), rig->state.mode_list); + rig_sprintf_mode(buf, sizeof(buf), rs->mode_list); char *p; cJSON *modes_array = cJSON_CreateArray(); @@ -113,6 +114,7 @@ static int snapshot_serialize_vfo(cJSON *vfo_node, RIG *rig, vfo_t vfo) int is_rx, is_tx; cJSON *node; struct rig_cache *cachep = CACHE(rig); + struct rig_state *rs = STATE(rig); // TODO: This data should match rig_get_info command response @@ -153,9 +155,9 @@ static int snapshot_serialize_vfo(cJSON *vfo_node, RIG *rig, vfo_t vfo) split = cachep->split; split_vfo = cachep->split_vfo; - is_rx = (split == RIG_SPLIT_OFF && vfo == rig->state.current_vfo) + is_rx = (split == RIG_SPLIT_OFF && vfo == rs->current_vfo) || (split == RIG_SPLIT_ON && vfo != split_vfo); - is_tx = (split == RIG_SPLIT_OFF && vfo == rig->state.current_vfo) + is_tx = (split == RIG_SPLIT_OFF && vfo == rs->current_vfo) || (split == RIG_SPLIT_ON && vfo == split_vfo); ptt = cachep->ptt && is_tx; @@ -336,6 +338,7 @@ int snapshot_serialize(size_t buffer_length, char *buffer, RIG *rig, char buf[256]; int result; int i; + struct rig_state *rs = STATE(rig); root_node = cJSON_CreateObject(); @@ -360,7 +363,7 @@ int snapshot_serialize(size_t buffer_length, char *buffer, RIG *rig, } node = cJSON_AddNumberToObject(root_node, "seq", - rig->state.snapshot_packet_sequence_number); + rs->snapshot_packet_sequence_number); if (node == NULL) { @@ -410,7 +413,7 @@ int snapshot_serialize(size_t buffer_length, char *buffer, RIG *rig, for (i = 0; i < HAMLIB_MAX_VFOS; i++) { - vfo_t vfo = rig->state.vfo_list & RIG_VFO_N(i); + vfo_t vfo = rs->vfo_list & RIG_VFO_N(i); if (!vfo) { @@ -464,7 +467,7 @@ int snapshot_serialize(size_t buffer_length, char *buffer, RIG *rig, RETURNFUNC2(-RIG_EINVAL); } - rig->state.snapshot_packet_sequence_number++; + rs->snapshot_packet_sequence_number++; return RIG_OK; diff --git a/src/tones.c b/src/tones.c index 768e377f3..86d0b1fcf 100644 --- a/src/tones.c +++ b/src/tones.c @@ -68,7 +68,7 @@ tone_t full_dcs_list[] = { FULL_DCS_LIST }; #ifndef DOC_HIDDEN -#define CHECK_RIG_ARG(r) (!(r) || !(r)->caps || !(r)->state.comm_state) +#define CHECK_RIG_ARG(r) (!(r) || !(r)->caps || !STATE(r)->comm_state) #endif /* !DOC_HIDDEN */ @@ -98,6 +98,7 @@ tone_t full_dcs_list[] = { FULL_DCS_LIST }; int HAMLIB_API rig_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone) { const struct rig_caps *caps; + struct rig_state *rs = STATE(rig); int retcode; vfo_t curr_vfo; @@ -117,7 +118,7 @@ int HAMLIB_API rig_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone) if ((caps->targetable_vfo & RIG_TARGETABLE_TONE) || vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == rs->current_vfo) { return caps->set_ctcss_tone(rig, vfo, tone); @@ -128,7 +129,7 @@ int HAMLIB_API rig_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone) return -RIG_ENTARGET; } - curr_vfo = rig->state.current_vfo; + curr_vfo = rs->current_vfo; retcode = caps->set_vfo(rig, vfo); if (retcode != RIG_OK) @@ -165,6 +166,7 @@ int HAMLIB_API rig_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone) int HAMLIB_API rig_get_ctcss_tone(RIG *rig, vfo_t vfo, tone_t *tone) { const struct rig_caps *caps; + struct rig_state *rs = STATE(rig); int retcode; vfo_t curr_vfo; @@ -184,7 +186,7 @@ int HAMLIB_API rig_get_ctcss_tone(RIG *rig, vfo_t vfo, tone_t *tone) if ((caps->targetable_vfo & RIG_TARGETABLE_TONE) || vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == rs->current_vfo) { return caps->get_ctcss_tone(rig, vfo, tone); @@ -195,7 +197,7 @@ int HAMLIB_API rig_get_ctcss_tone(RIG *rig, vfo_t vfo, tone_t *tone) return -RIG_ENTARGET; } - curr_vfo = rig->state.current_vfo; + curr_vfo = rs->current_vfo; retcode = caps->set_vfo(rig, vfo); if (retcode != RIG_OK) @@ -228,6 +230,7 @@ int HAMLIB_API rig_get_ctcss_tone(RIG *rig, vfo_t vfo, tone_t *tone) int HAMLIB_API rig_set_dcs_code(RIG *rig, vfo_t vfo, tone_t code) { const struct rig_caps *caps; + struct rig_state *rs = STATE(rig); int retcode; vfo_t curr_vfo; @@ -247,7 +250,7 @@ int HAMLIB_API rig_set_dcs_code(RIG *rig, vfo_t vfo, tone_t code) if ((caps->targetable_vfo & RIG_TARGETABLE_TONE) || vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == rs->current_vfo) { return caps->set_dcs_code(rig, vfo, code); @@ -258,7 +261,7 @@ int HAMLIB_API rig_set_dcs_code(RIG *rig, vfo_t vfo, tone_t code) return -RIG_ENTARGET; } - curr_vfo = rig->state.current_vfo; + curr_vfo = rs->current_vfo; retcode = caps->set_vfo(rig, vfo); if (retcode != RIG_OK) @@ -290,6 +293,7 @@ int HAMLIB_API rig_set_dcs_code(RIG *rig, vfo_t vfo, tone_t code) int HAMLIB_API rig_get_dcs_code(RIG *rig, vfo_t vfo, tone_t *code) { const struct rig_caps *caps; + struct rig_state *rs = STATE(rig); int retcode; vfo_t curr_vfo; @@ -309,7 +313,7 @@ int HAMLIB_API rig_get_dcs_code(RIG *rig, vfo_t vfo, tone_t *code) if ((caps->targetable_vfo & RIG_TARGETABLE_TONE) || vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == rs->current_vfo) { return caps->get_dcs_code(rig, vfo, code); @@ -320,7 +324,7 @@ int HAMLIB_API rig_get_dcs_code(RIG *rig, vfo_t vfo, tone_t *code) return -RIG_ENTARGET; } - curr_vfo = rig->state.current_vfo; + curr_vfo = rs->current_vfo; retcode = caps->set_vfo(rig, vfo); if (retcode != RIG_OK) @@ -360,6 +364,7 @@ int HAMLIB_API rig_get_dcs_code(RIG *rig, vfo_t vfo, tone_t *code) int HAMLIB_API rig_set_ctcss_sql(RIG *rig, vfo_t vfo, tone_t tone) { const struct rig_caps *caps; + struct rig_state *rs = STATE(rig); int retcode; vfo_t curr_vfo; @@ -379,7 +384,7 @@ int HAMLIB_API rig_set_ctcss_sql(RIG *rig, vfo_t vfo, tone_t tone) if ((caps->targetable_vfo & RIG_TARGETABLE_TONE) || vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == rs->current_vfo) { return caps->set_ctcss_sql(rig, vfo, tone); @@ -390,7 +395,7 @@ int HAMLIB_API rig_set_ctcss_sql(RIG *rig, vfo_t vfo, tone_t tone) return -RIG_ENTARGET; } - curr_vfo = rig->state.current_vfo; + curr_vfo = rs->current_vfo; retcode = caps->set_vfo(rig, vfo); if (retcode != RIG_OK) @@ -427,6 +432,7 @@ int HAMLIB_API rig_set_ctcss_sql(RIG *rig, vfo_t vfo, tone_t tone) int HAMLIB_API rig_get_ctcss_sql(RIG *rig, vfo_t vfo, tone_t *tone) { const struct rig_caps *caps; + struct rig_state *rs = STATE(rig); int retcode; vfo_t curr_vfo; @@ -446,7 +452,7 @@ int HAMLIB_API rig_get_ctcss_sql(RIG *rig, vfo_t vfo, tone_t *tone) if ((caps->targetable_vfo & RIG_TARGETABLE_TONE) || vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == rs->current_vfo) { return caps->get_ctcss_sql(rig, vfo, tone); @@ -457,7 +463,7 @@ int HAMLIB_API rig_get_ctcss_sql(RIG *rig, vfo_t vfo, tone_t *tone) return -RIG_ENTARGET; } - curr_vfo = rig->state.current_vfo; + curr_vfo = rs->current_vfo; retcode = caps->set_vfo(rig, vfo); if (retcode != RIG_OK) @@ -489,6 +495,7 @@ int HAMLIB_API rig_get_ctcss_sql(RIG *rig, vfo_t vfo, tone_t *tone) int HAMLIB_API rig_set_dcs_sql(RIG *rig, vfo_t vfo, tone_t code) { const struct rig_caps *caps; + struct rig_state *rs = STATE(rig); int retcode; vfo_t curr_vfo; @@ -508,7 +515,7 @@ int HAMLIB_API rig_set_dcs_sql(RIG *rig, vfo_t vfo, tone_t code) if ((caps->targetable_vfo & RIG_TARGETABLE_TONE) || vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == rs->current_vfo) { return caps->set_dcs_sql(rig, vfo, code); @@ -519,7 +526,7 @@ int HAMLIB_API rig_set_dcs_sql(RIG *rig, vfo_t vfo, tone_t code) return -RIG_ENTARGET; } - curr_vfo = rig->state.current_vfo; + curr_vfo = rs->current_vfo; retcode = caps->set_vfo(rig, vfo); if (retcode != RIG_OK) @@ -551,6 +558,7 @@ int HAMLIB_API rig_set_dcs_sql(RIG *rig, vfo_t vfo, tone_t code) int HAMLIB_API rig_get_dcs_sql(RIG *rig, vfo_t vfo, tone_t *code) { const struct rig_caps *caps; + struct rig_state *rs = STATE(rig); int retcode; vfo_t curr_vfo; @@ -570,7 +578,7 @@ int HAMLIB_API rig_get_dcs_sql(RIG *rig, vfo_t vfo, tone_t *code) if ((caps->targetable_vfo & RIG_TARGETABLE_TONE) || vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == rs->current_vfo) { return caps->get_dcs_sql(rig, vfo, code); @@ -581,7 +589,7 @@ int HAMLIB_API rig_get_dcs_sql(RIG *rig, vfo_t vfo, tone_t *code) return -RIG_ENTARGET; } - curr_vfo = rig->state.current_vfo; + curr_vfo = rs->current_vfo; retcode = caps->set_vfo(rig, vfo); if (retcode != RIG_OK) From 02102f60e4a1fcbbbf467e07eb803b0aa2a1c9d4 Mon Sep 17 00:00:00 2001 From: George Baltz N3GB Date: Mon, 1 Jul 2024 16:25:08 -0400 Subject: [PATCH 3/4] Convert all rig->state. references in src/rig.c to pointers. Remove obsolete comment Fix possible cppcheck squawks/errors after conversion from substructures to real pointers. --- src/conf.c | 1 - src/rig.c | 419 ++++++++++++++++++++++++++++++----------------------- 2 files changed, 235 insertions(+), 185 deletions(-) diff --git a/src/conf.c b/src/conf.c index 8580f7e2a..c54a8f6f0 100644 --- a/src/conf.c +++ b/src/conf.c @@ -595,7 +595,6 @@ static int frontend_set_conf(RIG *rig, hamlib_token_t token, const char *val) } // JTDX and WSJTX currently use state.pttport to check for PTT_NONE -// rig->state.pttport.type.ptt = pttp->type.ptt; rs->pttport_deprecated.type.ptt = pttp->type.ptt; break; diff --git a/src/rig.c b/src/rig.c index c42bde1b5..a047442f0 100644 --- a/src/rig.c +++ b/src/rig.c @@ -166,10 +166,10 @@ const char hamlib_copyright[231] = /* hamlib 1.2 ABI specifies 231 bytes */ #define DEFAULT_GPIO_PORT "0" -#define CHECK_RIG_ARG(r) (!(r) || !(r)->caps || !(r)->state.comm_state) +#define CHECK_RIG_ARG(r) (!(r) || !(r)->caps || !STATE((r))->comm_state) #define CHECK_RIG_CAPS(r) (!(r) || !(r)->caps) -#define LOCK(n) if (rig->state.depth == 1) { rig_debug(RIG_DEBUG_CACHE, "%s: %s\n", n?"lock":"unlock", __func__); rig_lock(rig,n); } +#define LOCK(n) if (STATE(rig)->depth == 1) { rig_debug(RIG_DEBUG_CACHE, "%s: %s\n", n?"lock":"unlock", __func__); rig_lock(rig,n); } MUTEX(morse_mutex); @@ -1411,7 +1411,7 @@ int HAMLIB_API rig_open(RIG *rig) } // don't need auto_power_on if power is already on - if (status == RIG_OK && powerflag == RIG_POWER_ON) { rig->state.auto_power_on = 0; } + if (status == RIG_OK && powerflag == RIG_POWER_ON) { STATE(rig)->auto_power_on = 0; } if (status == -RIG_ETIMEOUT) { @@ -1649,7 +1649,7 @@ int HAMLIB_API rig_close(RIG *rig) remove_opened_rig(rig); - rig->state.comm_status = RIG_COMM_STATUS_DISCONNECTED; + rs->comm_status = RIG_COMM_STATUS_DISCONNECTED; #if defined(HAVE_PTHREAD) @@ -1811,7 +1811,7 @@ int HAMLIB_API rig_cleanup(RIG *rig) /* * check if they forgot to close the rig */ - if (rig->state.comm_state) + if (STATE(rig)->comm_state) { rig_close(rig); } @@ -1855,7 +1855,7 @@ int HAMLIB_API rig_set_twiddle(RIG *rig, int seconds) ENTERFUNC; - rig->state.twiddle_timeout = seconds; + STATE(rig)->twiddle_timeout = seconds; RETURNFUNC(RIG_OK); } @@ -1879,7 +1879,7 @@ int HAMLIB_API rig_set_uplink(RIG *rig, int val) ENTERFUNC; - rig->state.uplink = val; + STATE(rig)->uplink = val; RETURNFUNC(RIG_OK); } @@ -1906,7 +1906,7 @@ int HAMLIB_API rig_get_twiddle(RIG *rig, int *seconds) ENTERFUNC; - *seconds = rig->state.twiddle_timeout; + *seconds = STATE(rig)->twiddle_timeout; RETURNFUNC(RIG_OK); } @@ -1972,19 +1972,21 @@ static int twiddling(RIG *rig) static int skip_freq(RIG *rig, vfo_t vfo) { struct rig_cache *cachep = CACHE(rig); + struct rig_state *rs = STATE(rig); int retval = 0; + // if option is not select do not skip // WSJT-X needs set all the time....gpredict can skip // This is due to their behavior...WSJT-X sets TX VFO before PTT // gpredict needs to set Doppler all the time so causes VFO flashing on rigs without TARGETABLE_FREQ - if (rig->state.freq_skip == 0) + if (rs->freq_skip == 0) { rig_debug(RIG_DEBUG_VERBOSE, "%s: not skipping set_freq on vfo %s\n", __func__, rig_strvfo(vfo)); return 0; } if (cachep->ptt && cachep->split && ((rig->caps->targetable_vfo & RIG_TARGETABLE_FREQ) == 0) - && (vfo == RIG_VFO_RX || vfo == rig->state.rx_vfo)) + && (vfo == RIG_VFO_RX || vfo == rs->rx_vfo)) { rig_debug(RIG_DEBUG_VERBOSE, "%s: skip setting frequency on RX vfo when PTT is on\n", __func__); @@ -1993,7 +1995,7 @@ static int skip_freq(RIG *rig, vfo_t vfo) if ((!cachep->ptt) && cachep->split && ((rig->caps->targetable_vfo & RIG_TARGETABLE_FREQ) == 0) - && (vfo == RIG_VFO_TX || vfo == rig->state.tx_vfo)) + && (vfo == RIG_VFO_TX || vfo == rs->tx_vfo)) { rig_debug(RIG_DEBUG_VERBOSE, "%s: skip setting frequency on TX vfo when PTT is not on\n", __func__); @@ -2026,7 +2028,8 @@ int rig_set_freq(RIG *rig, vfo_t vfo, freq_t freq) #endif { const struct rig_caps *caps; - struct rig_cache *cachep = CACHE(rig); + struct rig_cache *cachep; + struct rig_state *rs; int retcode; freq_t freq_new = freq; vfo_t vfo_save; @@ -2040,9 +2043,12 @@ int rig_set_freq(RIG *rig, vfo_t vfo, freq_t freq) return -RIG_EINVAL; } + cachep = CACHE(rig); + rs = STATE(rig); + curr_band = rig_get_band(rig, freq, -1); - if (rig->state.tx_vfo == vfo && curr_band != last_band) + if (rs->tx_vfo == vfo && curr_band != last_band) { struct rig_cache *cachep = CACHE(rig); rig_debug(RIG_DEBUG_VERBOSE, "%s: band changing to %s\n", __func__, @@ -2070,60 +2076,60 @@ int rig_set_freq(RIG *rig, vfo_t vfo, freq_t freq) rig_strvfo(vfo), freq); #endif - if (rig->state.doppler == 0) + if (rs->doppler == 0) { if (vfo == RIG_VFO_A || vfo == RIG_VFO_MAIN || (vfo == RIG_VFO_CURR - && rig->state.current_vfo == RIG_VFO_A)) + && rs->current_vfo == RIG_VFO_A)) { if (cachep->freqMainA != freq && (((int)freq % 10) != 0) && (((int)freq % 100) != 55)) { - rig->state.doppler = 1; + rs->doppler = 1; rig_debug(RIG_DEBUG_VERBOSE, "%s(%d): potential doppler detected because old freq %f != new && new freq has 1Hz or such values\n", __func__, __LINE__, cachep->freqMainA); } - freq += rig->state.offset_vfoa; + freq += rs->offset_vfoa; } else if (vfo == RIG_VFO_B || vfo == RIG_VFO_SUB || (vfo == RIG_VFO_CURR - && rig->state.current_vfo == RIG_VFO_B)) + && rs->current_vfo == RIG_VFO_B)) { if (cachep->freqMainB != freq && ((int)freq % 10) != 0 && (((int)freq % 100) != 55)) { - rig->state.doppler = 1; + rs->doppler = 1; rig_debug(RIG_DEBUG_VERBOSE, "%s(%d): potential doppler detected because old freq %f != new && new freq has 1Hz or such values\n", __func__, __LINE__, cachep->freqMainB); } - freq += rig->state.offset_vfob; + freq += rs->offset_vfob; } } - if (vfo == RIG_VFO_A || vfo == RIG_VFO_MAIN) { freq += rig->state.offset_vfoa; } - else if (vfo == RIG_VFO_B || vfo == RIG_VFO_SUB) { freq += rig->state.offset_vfob; } + if (vfo == RIG_VFO_A || vfo == RIG_VFO_MAIN) { freq += rs->offset_vfoa; } + else if (vfo == RIG_VFO_B || vfo == RIG_VFO_SUB) { freq += rs->offset_vfob; } - if (rig->state.twiddle_state == TWIDDLE_ON) + if (rs->twiddle_state == TWIDDLE_ON) { // we keep skipping set_freq while the vfo knob is in motion rig_debug(RIG_DEBUG_VERBOSE, "%s: Twiddle on so skipping this set_freq request one time\n", __func__); - rig->state.twiddle_state = TWIDDLE_OFF; + rs->twiddle_state = TWIDDLE_OFF; } caps = rig->caps; - if (rig->state.lo_freq != 0.0) + if (rs->lo_freq != 0.0) { - freq -= rig->state.lo_freq; + freq -= rs->lo_freq; } - if (rig->state.vfo_comp != 0.0) + if (rs->vfo_comp != 0.0) { - freq += (freq_t)((double)rig->state.vfo_comp * freq); + freq += (freq_t)((double)rs->vfo_comp * freq); } if (caps->set_freq == NULL) @@ -2133,7 +2139,7 @@ int rig_set_freq(RIG *rig, vfo_t vfo, freq_t freq) RETURNFUNC(-RIG_ENAVAIL); } - vfo_save = rig->state.current_vfo; + vfo_save = rs->current_vfo; vfo = vfo_fixup(rig, vfo, cachep->split); if (vfo == RIG_VFO_CURR) @@ -2149,7 +2155,7 @@ int rig_set_freq(RIG *rig, vfo_t vfo, freq_t freq) } if ((caps->targetable_vfo & RIG_TARGETABLE_FREQ) - || vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) + || vfo == RIG_VFO_CURR || vfo == rs->current_vfo) { if (twiddling(rig)) { @@ -2291,7 +2297,7 @@ int rig_set_freq(RIG *rig, vfo_t vfo, freq_t freq) ) { // some rigs we can skip this check for speed sake - if (rig->state.rig_model == RIG_MODEL_MALACHITE) + if (rs->rig_model == RIG_MODEL_MALACHITE) { rig_set_cache_freq(rig, vfo, freq); ELAPSED2; @@ -2327,7 +2333,7 @@ int rig_set_freq(RIG *rig, vfo_t vfo, freq_t freq) } // update our current freq too - if (vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) { rig->state.current_freq = freq_new; } + if (vfo == RIG_VFO_CURR || vfo == rs->current_vfo) { rs->current_freq = freq_new; } rig_set_cache_freq(rig, vfo, freq_new); @@ -2368,7 +2374,8 @@ int HAMLIB_API rig_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) #endif { const struct rig_caps *caps; - struct rig_cache *cachep = CACHE(rig); + struct rig_cache *cachep; + struct rig_state *rs; int retcode; vfo_t curr_vfo; rmode_t mode; @@ -2383,6 +2390,9 @@ int HAMLIB_API rig_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) return -RIG_EINVAL; } + rs = STATE(rig); + cachep = CACHE(rig); + ENTERFUNC; #if BUILTINFUNC rig_debug(RIG_DEBUG_VERBOSE, "%s called vfo=%s, called from %s\n", @@ -2406,7 +2416,7 @@ int HAMLIB_API rig_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) rig_cache_show(rig, __func__, __LINE__); - curr_vfo = rig->state.current_vfo; // save vfo for restore later + curr_vfo = rs->current_vfo; // save vfo for restore later vfo = vfo_fixup(rig, vfo, cachep->split); @@ -2421,16 +2431,16 @@ int HAMLIB_API rig_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) if (vfo == RIG_VFO_CURR) { vfo = curr_vfo; } // we ignore get_freq for the uplink VFO for gpredict to behave better - if ((rig->state.uplink == 1 && vfo == RIG_VFO_SUB) - || (rig->state.uplink == 2 && vfo == RIG_VFO_MAIN) + if ((rs->uplink == 1 && vfo == RIG_VFO_SUB) + || (rs->uplink == 2 && vfo == RIG_VFO_MAIN) || (vfo == RIG_VFO_TX && cachep->ptt == 0) || use_cache) { rig_debug(RIG_DEBUG_TRACE, "%s: uplink=%d, ignoring get_freq\n", __func__, - rig->state.uplink); + rs->uplink); rig_debug(RIG_DEBUG_TRACE, "%s: split=%d, satmode=%d, tx_vfo=%s\n", __func__, cachep->split, cachep->satmode, - rig_strvfo(rig->state.tx_vfo)); + rig_strvfo(rs->tx_vfo)); // always return the cached freq for this clause int cache_ms_freq, cache_ms_mode, cache_ms_width; rig_get_cache(rig, vfo, freq, &cache_ms_freq, &mode, &cache_ms_mode, &width, @@ -2442,9 +2452,9 @@ int HAMLIB_API rig_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) rig_cache_show(rig, __func__, __LINE__); LOCK(1); - rig_debug(RIG_DEBUG_CACHE, "%s: depth=%d\n", __func__, rig->state.depth); + rig_debug(RIG_DEBUG_CACHE, "%s: depth=%d\n", __func__, rs->depth); - if (rig->state.depth == 1) + if (rs->depth == 1) { rig_debug(RIG_DEBUG_CACHE, "%s: %s\n", 1 ? "lock" : "unlock", __func__); // rig_lock(rig, 1); @@ -2496,11 +2506,11 @@ int HAMLIB_API rig_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) if (!wsjtx_special && *freq != 0 && (cache_ms_freq < cachep->timeout_ms || (cachep->timeout_ms == HAMLIB_CACHE_ALWAYS - || rig->state.use_cached_freq))) + || rs->use_cached_freq))) { rig_debug(RIG_DEBUG_TRACE, "%s: %s cache hit age=%dms, freq=%.0f, use_cached_freq=%d\n", __func__, - rig_strvfo(vfo), cache_ms_freq, *freq, rig->state.use_cached_freq); + rig_strvfo(vfo), cache_ms_freq, *freq, rs->use_cached_freq); ELAPSED2; LOCK(0); RETURNFUNC(RIG_OK); @@ -2511,7 +2521,7 @@ int HAMLIB_API rig_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) "%s: cache miss age=%dms, cached_vfo=%s, asked_vfo=%s, use_cached_freq=%d\n", __func__, cache_ms_freq, - rig_strvfo(vfo), rig_strvfo(vfo), rig->state.use_cached_freq); + rig_strvfo(vfo), rig_strvfo(vfo), rs->use_cached_freq); } caps = rig->caps; @@ -2524,14 +2534,14 @@ int HAMLIB_API rig_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) } rig_debug(RIG_DEBUG_VERBOSE, "%s(%d): vfo_opt=%d, model=%u\n", __func__, - __LINE__, rig->state.vfo_opt, rig->caps->rig_model); + __LINE__, rs->vfo_opt, rig->caps->rig_model); // If we're in vfo_mode then rigctld will do any VFO swapping we need // If we detected doppler we skip the frequency check to make timing more consistent for relay control if ((caps->targetable_vfo & RIG_TARGETABLE_FREQ) - || vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo - || (rig->state.vfo_opt == 1 && rig->caps->rig_model == RIG_MODEL_NETRIGCTL - && rig->state.doppler == 0)) + || vfo == RIG_VFO_CURR || vfo == rs->current_vfo + || (rs->vfo_opt == 1 && rig->caps->rig_model == RIG_MODEL_NETRIGCTL + && rs->doppler == 0)) { // If rig does not have set_vfo we need to change vfo if (vfo == RIG_VFO_CURR && caps->set_vfo == NULL) @@ -2615,20 +2625,20 @@ int HAMLIB_API rig_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) } /* VFO compensation */ - if (rig->state.vfo_comp != 0.0) + if (rs->vfo_comp != 0.0) { - *freq = (freq_t)(*freq / (1.0 + (double)rig->state.vfo_comp)); + *freq = (freq_t)(*freq / (1.0 + (double)rs->vfo_comp)); } if (retcode == RIG_OK - && (vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo)) + && (vfo == RIG_VFO_CURR || vfo == rs->current_vfo)) { - rig->state.current_freq = *freq; + rs->current_freq = *freq; } - if (rig->state.lo_freq != 0.0) + if (rs->lo_freq != 0.0) { - *freq += rig->state.lo_freq; + *freq += rs->lo_freq; } if (retcode == RIG_OK) @@ -2644,12 +2654,12 @@ int HAMLIB_API rig_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) } // we only want to look for band change on main vfo for now - if (*freq != 0 && (rig->state.current_vfo == RIG_VFO_A - || rig->state.current_vfo == RIG_VFO_MAIN)) + if (*freq != 0 && (rs->current_vfo == RIG_VFO_A + || rs->current_vfo == RIG_VFO_MAIN)) { curr_band = rig_get_band(rig, *freq, -1); - if (rig->state.tx_vfo == vfo && curr_band != last_band) + if (rs->tx_vfo == vfo && curr_band != last_band) { rig_debug(RIG_DEBUG_VERBOSE, "%s: band changing to %s\n", __func__, rig_get_band_str(rig, curr_band, 0)); @@ -2710,9 +2720,10 @@ int HAMLIB_API rig_get_freqs(RIG *rig, freq_t *freqA, freq_t freqB) int HAMLIB_API rig_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) { const struct rig_caps *caps; + struct rig_state *rs; int retcode; int locked_mode; - struct rig_cache *cachep = CACHE(rig); + struct rig_cache *cachep; if (CHECK_RIG_ARG(rig)) { @@ -2720,6 +2731,9 @@ int HAMLIB_API rig_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) return -RIG_EINVAL; } + rs = STATE(rig); + cachep = CACHE(rig); + ENTERFUNC; ELAPSED1; LOCK(1); @@ -2727,7 +2741,7 @@ int HAMLIB_API rig_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) rig_debug(RIG_DEBUG_VERBOSE, "%s called, vfo=%s, mode=%s, width=%d, curr_vfo=%s\n", __func__, rig_strvfo(vfo), rig_strrmode(mode), (int)width, - rig_strvfo(rig->state.current_vfo)); + rig_strvfo(rs->current_vfo)); rig_get_lock_mode(rig, &locked_mode); @@ -2755,7 +2769,7 @@ int HAMLIB_API rig_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) if (vfo == RIG_VFO_CURR) { - vfo = rig->state.current_vfo; + vfo = rs->current_vfo; } if (mode == RIG_MODE_NONE) @@ -2789,7 +2803,7 @@ int HAMLIB_API rig_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) } if ((caps->targetable_vfo & RIG_TARGETABLE_MODE) - || vfo == rig->state.current_vfo) + || vfo == rs->current_vfo) { HAMLIB_TRACE; retcode = caps->set_mode(rig, vfo, mode, width); @@ -2803,7 +2817,7 @@ int HAMLIB_API rig_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) // If the rig does not support targetable mode, only set mode on an unselected if it is changing // to avoid unnecessary VFO swapping - if (vfo != rig->state.current_vfo) + if (vfo != rs->current_vfo) { freq_t cache_freq; rmode_t cache_mode; @@ -2833,7 +2847,7 @@ int HAMLIB_API rig_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) RETURNFUNC(-RIG_ENAVAIL); } - curr_vfo = rig->state.current_vfo; + curr_vfo = rs->current_vfo; rig_debug(RIG_DEBUG_VERBOSE, "%s(%d): curr_vfo=%s, vfo=%s\n", __func__, __LINE__, rig_strvfo(curr_vfo), rig_strvfo(vfo)); HAMLIB_TRACE; @@ -2901,11 +2915,12 @@ int HAMLIB_API rig_get_mode(RIG *rig, pbwidth_t *width) { const struct rig_caps *caps; + struct rig_state *rs; int retcode; int use_cache = 0; freq_t freq; vfo_t curr_vfo; - struct rig_cache *cachep = CACHE(rig); + struct rig_cache *cachep; if (CHECK_RIG_ARG(rig)) { @@ -2923,6 +2938,8 @@ int HAMLIB_API rig_get_mode(RIG *rig, } caps = rig->caps; + rs = STATE(rig); + cachep = CACHE(rig); if (caps->get_mode == NULL) { @@ -2930,7 +2947,7 @@ int HAMLIB_API rig_get_mode(RIG *rig, RETURNFUNC(-RIG_ENAVAIL); } - curr_vfo = rig->state.current_vfo; + curr_vfo = rs->current_vfo; vfo = vfo_fixup(rig, vfo, cachep->split); if (vfo == RIG_VFO_CURR) { vfo = curr_vfo; } @@ -2951,7 +2968,7 @@ int HAMLIB_API rig_get_mode(RIG *rig, } if (cachep->timeout_ms == HAMLIB_CACHE_ALWAYS - || rig->state.use_cached_mode || use_cache) + || rs->use_cached_mode || use_cache) { rig_debug(RIG_DEBUG_TRACE, "%s: cache hit age mode=%dms, width=%dms\n", __func__, cache_ms_mode, cache_ms_width); @@ -2979,7 +2996,7 @@ int HAMLIB_API rig_get_mode(RIG *rig, if ((caps->targetable_vfo & RIG_TARGETABLE_MODE) || vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == rs->current_vfo) { HAMLIB_TRACE; retcode = caps->get_mode(rig, vfo, mode, width); @@ -3025,11 +3042,11 @@ int HAMLIB_API rig_get_mode(RIG *rig, } if (retcode == RIG_OK - && (vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo)) + && (vfo == RIG_VFO_CURR || vfo == rs->current_vfo)) { rig_debug(RIG_DEBUG_TRACE, "%s(%d): debug\n", __func__, __LINE__); - rig->state.current_mode = *mode; - rig->state.current_width = *width; + rs->current_mode = *mode; + rs->current_width = *width; rig_cache_show(rig, __func__, __LINE__); } @@ -3227,7 +3244,8 @@ int HAMLIB_API rig_set_vfo(RIG *rig, vfo_t vfo) #endif { const struct rig_caps *caps; - struct rig_cache *cachep = CACHE(rig); + struct rig_cache *cachep; + struct rig_state *rs; int retcode; freq_t curr_freq; vfo_t curr_vfo = RIG_VFO_CURR, tmp_vfo; @@ -3238,6 +3256,9 @@ int HAMLIB_API rig_set_vfo(RIG *rig, vfo_t vfo) return -RIG_EINVAL; } + rs = STATE(rig); + cachep = CACHE(rig); + ELAPSED1; ENTERFUNC; #if BUILTINFUNC @@ -3294,27 +3315,27 @@ int HAMLIB_API rig_set_vfo(RIG *rig, vfo_t vfo) } HAMLIB_TRACE; - vfo_t vfo_save = rig->state.current_vfo; + vfo_t vfo_save = rs->current_vfo; LOCK(1); - if (vfo != RIG_VFO_CURR) { rig->state.current_vfo = vfo; } + if (vfo != RIG_VFO_CURR) { rs->current_vfo = vfo; } retcode = caps->set_vfo(rig, vfo); if (retcode == RIG_OK) { - vfo = rig->state.current_vfo; // vfo may change in the rig backend + vfo = rs->current_vfo; // vfo may change in the rig backend cachep->vfo = vfo; elapsed_ms(&cachep->time_vfo, HAMLIB_ELAPSED_SET); - rig_debug(RIG_DEBUG_TRACE, "%s: rig->state.current_vfo=%s\n", __func__, + rig_debug(RIG_DEBUG_TRACE, "%s: rs->current_vfo=%s\n", __func__, rig_strvfo(vfo)); } else { rig_debug(RIG_DEBUG_ERR, "%s: set_vfo %s failed with '%.10000s'\n", __func__, rig_strvfo(vfo), rigerror(retcode)); - rig->state.current_vfo = vfo_save; + rs->current_vfo = vfo_save; } // we need to update our internal freq to avoid getting detected as twiddling @@ -3334,7 +3355,7 @@ int HAMLIB_API rig_set_vfo(RIG *rig, vfo_t vfo) rig_set_cache_freq(rig, RIG_VFO_ALL, (freq_t)0); } - if (vfo != rig->state.current_vfo && rig_get_vfo(rig, &tmp_vfo) == -RIG_ENAVAIL) + if (vfo != rs->current_vfo && rig_get_vfo(rig, &tmp_vfo) == -RIG_ENAVAIL) { rig_debug(RIG_DEBUG_TRACE, "%s: Expiring all cache due to VFO change and no get_vfo\n", __func__); @@ -3344,7 +3365,7 @@ int HAMLIB_API rig_set_vfo(RIG *rig, vfo_t vfo) rig_debug(RIG_DEBUG_TRACE, "%s: return %d, vfo=%s, curr_vfo=%s\n", __func__, retcode, - rig_strvfo(vfo), rig_strvfo(rig->state.current_vfo)); + rig_strvfo(vfo), rig_strvfo(rs->current_vfo)); ELAPSED2; LOCK(0); RETURNFUNC(retcode); @@ -3369,7 +3390,8 @@ int HAMLIB_API rig_set_vfo(RIG *rig, vfo_t vfo) int HAMLIB_API rig_get_vfo(RIG *rig, vfo_t *vfo) { const struct rig_caps *caps; - struct rig_cache *cachep = CACHE(rig); + struct rig_cache *cachep; + struct rig_state *rs; int retcode = -RIG_EINTERNAL; int cache_ms; int use_cache = 0; @@ -3384,6 +3406,8 @@ int HAMLIB_API rig_get_vfo(RIG *rig, vfo_t *vfo) ELAPSED1; caps = rig->caps; + rs = STATE(rig); + cachep = CACHE(rig); // if (caps->get_vfo == NULL && RIG_ICOM != RIG_BACKEND_NUM(rig->caps->rig_model)) if (caps->get_vfo == NULL) @@ -3423,7 +3447,7 @@ int HAMLIB_API rig_get_vfo(RIG *rig, vfo_t *vfo) if (retcode == RIG_OK) { - rig->state.current_vfo = *vfo; + rs->current_vfo = *vfo; cachep->vfo = *vfo; //cache_ms = elapsed_ms(&cachep->time_vfo, HAMLIB_ELAPSED_SET); } @@ -3462,10 +3486,9 @@ int HAMLIB_API rig_get_vfo(RIG *rig, vfo_t *vfo) int HAMLIB_API rig_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt) { const struct rig_caps *caps; - struct rig_state *rs = STATE(rig); - hamlib_port_t *rp = RIGPORT(rig); - hamlib_port_t *pttp = PTTPORT(rig); - struct rig_cache *cachep = CACHE(rig); + struct rig_state *rs; + hamlib_port_t *rp, *pttp; + struct rig_cache *cachep; int retcode = RIG_OK; if (CHECK_RIG_ARG(rig)) @@ -3478,6 +3501,10 @@ int HAMLIB_API rig_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt) ENTERFUNC; caps = rig->caps; + rs = STATE(rig); + cachep = CACHE(rig); + rp = RIGPORT(rig); + pttp = PTTPORT(rig); LOCK(1); @@ -3500,7 +3527,7 @@ int HAMLIB_API rig_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt) if ((caps->targetable_vfo & RIG_TARGETABLE_PTT) || vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == rs->current_vfo) { int retry = 3; ptt_t tptt; @@ -3555,7 +3582,7 @@ int HAMLIB_API rig_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt) RETURNFUNC(-RIG_ENAVAIL); } - curr_vfo = rig->state.current_vfo; + curr_vfo = rs->current_vfo; HAMLIB_TRACE; backend_num = RIG_BACKEND_NUM(rig->caps->rig_model); @@ -3762,10 +3789,10 @@ int HAMLIB_API rig_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt) if (retcode != RIG_OK) { rig_debug(RIG_DEBUG_ERR, "%s: return code=%d\n", __func__, retcode); } - memcpy(&rig->state.pttport_deprecated, pttp, - sizeof(rig->state.pttport_deprecated)); + memcpy(&rs->pttport_deprecated, pttp, + sizeof(rs->pttport_deprecated)); - if (rig->state.post_ptt_delay > 0) { hl_usleep(rig->state.post_ptt_delay * 1000); } + if (rs->post_ptt_delay > 0) { hl_usleep(rs->post_ptt_delay * 1000); } ELAPSED2; @@ -3790,10 +3817,9 @@ int HAMLIB_API rig_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt) int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt) { const struct rig_caps *caps; - struct rig_state *rs = STATE(rig); - hamlib_port_t *rp = RIGPORT(rig); - hamlib_port_t *pttp = PTTPORT(rig); - struct rig_cache *cachep = CACHE(rig); + struct rig_state *rs; + hamlib_port_t *rp, *pttp; + struct rig_cache *cachep; int retcode = RIG_OK; int status; vfo_t curr_vfo; @@ -3807,6 +3833,11 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt) return -RIG_EINVAL; } + rs = STATE(rig); + cachep = CACHE(rig); + rp = RIGPORT(rig); + pttp = PTTPORT(rig); + ELAPSED1; ENTERFUNC; @@ -3849,7 +3880,7 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt) if ((caps->targetable_vfo & RIG_TARGETABLE_PTT) || vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == rs->current_vfo) { HAMLIB_TRACE; retcode = caps->get_ptt(rig, vfo, ptt); @@ -3872,7 +3903,7 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt) RETURNFUNC(-RIG_ENAVAIL); } - curr_vfo = rig->state.current_vfo; + curr_vfo = rs->current_vfo; HAMLIB_TRACE; backend_num = RIG_BACKEND_NUM(rig->caps->rig_model); @@ -4111,7 +4142,8 @@ int HAMLIB_API rig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt) int HAMLIB_API rig_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd) { const struct rig_caps *caps; - hamlib_port_t *dcdp = DCDPORT(rig); + struct rig_state *rs; + hamlib_port_t *dcdp; int retcode, rc2, status; vfo_t curr_vfo; @@ -4131,6 +4163,8 @@ int HAMLIB_API rig_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd) } caps = rig->caps; + rs = STATE(rig); + dcdp = DCDPORT(rig); switch (dcdp->type.dcd) { @@ -4142,7 +4176,7 @@ int HAMLIB_API rig_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd) } if (vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == rs->current_vfo) { HAMLIB_TRACE; retcode = caps->get_dcd(rig, vfo, dcd); @@ -4156,7 +4190,7 @@ int HAMLIB_API rig_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd) RETURNFUNC(-RIG_ENAVAIL); } - curr_vfo = rig->state.current_vfo; + curr_vfo = rs->current_vfo; HAMLIB_TRACE; retcode = caps->set_vfo(rig, vfo); @@ -4184,24 +4218,24 @@ int HAMLIB_API rig_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd) case RIG_DCD_SERIAL_CTS: retcode = ser_get_cts(dcdp, &status); - memcpy(&rig->state.dcdport_deprecated, dcdp, - sizeof(rig->state.dcdport_deprecated)); + memcpy(&rs->dcdport_deprecated, dcdp, + sizeof(rs->dcdport_deprecated)); *dcd = status ? RIG_DCD_ON : RIG_DCD_OFF; ELAPSED2; RETURNFUNC(retcode); case RIG_DCD_SERIAL_DSR: retcode = ser_get_dsr(dcdp, &status); - memcpy(&rig->state.dcdport_deprecated, dcdp, - sizeof(rig->state.dcdport_deprecated)); + memcpy(&rs->dcdport_deprecated, dcdp, + sizeof(rs->dcdport_deprecated)); *dcd = status ? RIG_DCD_ON : RIG_DCD_OFF; ELAPSED2; RETURNFUNC(retcode); case RIG_DCD_SERIAL_CAR: retcode = ser_get_car(dcdp, &status); - memcpy(&rig->state.dcdport_deprecated, dcdp, - sizeof(rig->state.dcdport_deprecated)); + memcpy(&rs->dcdport_deprecated, dcdp, + sizeof(rs->dcdport_deprecated)); *dcd = status ? RIG_DCD_ON : RIG_DCD_OFF; ELAPSED2; RETURNFUNC(retcode); @@ -4209,16 +4243,16 @@ int HAMLIB_API rig_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd) case RIG_DCD_PARALLEL: retcode = par_dcd_get(dcdp, dcd); - memcpy(&rig->state.dcdport_deprecated, dcdp, - sizeof(rig->state.dcdport_deprecated)); + memcpy(&rs->dcdport_deprecated, dcdp, + sizeof(rs->dcdport_deprecated)); ELAPSED2; RETURNFUNC(retcode); case RIG_DCD_GPIO: case RIG_DCD_GPION: retcode = gpio_dcd_get(dcdp, dcd); - memcpy(&rig->state.dcdport_deprecated, dcdp, - sizeof(rig->state.dcdport_deprecated)); + memcpy(&rs->dcdport_deprecated, dcdp, + sizeof(rs->dcdport_deprecated)); ELAPSED2; RETURNFUNC(retcode); @@ -4274,7 +4308,7 @@ int HAMLIB_API rig_set_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t rptr_shift) } if (vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == STATE(rig)->current_vfo) { HAMLIB_TRACE; retcode = caps->set_rptr_shift(rig, vfo, rptr_shift); @@ -4288,7 +4322,7 @@ int HAMLIB_API rig_set_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t rptr_shift) RETURNFUNC(-RIG_ENAVAIL); } - curr_vfo = rig->state.current_vfo; + curr_vfo = STATE(rig)->current_vfo; HAMLIB_TRACE; retcode = caps->set_vfo(rig, vfo); @@ -4358,7 +4392,7 @@ int HAMLIB_API rig_get_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t *rptr_shift) } if (vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == STATE(rig)->current_vfo) { HAMLIB_TRACE; retcode = caps->get_rptr_shift(rig, vfo, rptr_shift); @@ -4372,7 +4406,7 @@ int HAMLIB_API rig_get_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t *rptr_shift) RETURNFUNC(-RIG_ENAVAIL); } - curr_vfo = rig->state.current_vfo; + curr_vfo = STATE(rig)->current_vfo; HAMLIB_TRACE; retcode = caps->set_vfo(rig, vfo); @@ -4436,7 +4470,7 @@ int HAMLIB_API rig_set_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t rptr_offs) } if (vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == STATE(rig)->current_vfo) { HAMLIB_TRACE; retcode = caps->set_rptr_offs(rig, vfo, rptr_offs); @@ -4450,7 +4484,7 @@ int HAMLIB_API rig_set_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t rptr_offs) RETURNFUNC(-RIG_ENAVAIL); } - curr_vfo = rig->state.current_vfo; + curr_vfo = STATE(rig)->current_vfo; HAMLIB_TRACE; retcode = caps->set_vfo(rig, vfo); @@ -4519,7 +4553,7 @@ int HAMLIB_API rig_get_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t *rptr_offs) } if (vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == STATE(rig)->current_vfo) { HAMLIB_TRACE; retcode = caps->get_rptr_offs(rig, vfo, rptr_offs); @@ -4533,7 +4567,7 @@ int HAMLIB_API rig_get_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t *rptr_offs) RETURNFUNC(-RIG_ENAVAIL); } - curr_vfo = rig->state.current_vfo; + curr_vfo = STATE(rig)->current_vfo; HAMLIB_TRACE; retcode = caps->set_vfo(rig, vfo); @@ -4576,7 +4610,7 @@ int HAMLIB_API rig_set_split_freq(RIG *rig, vfo_t vfo, freq_t tx_freq) { const struct rig_caps *caps; const struct rig_state *rs; - struct rig_cache *cachep = CACHE(rig); + struct rig_cache *cachep; int retcode, rc2; vfo_t curr_vfo, tx_vfo = RIG_VFO_CURR; freq_t tfreq = 0; @@ -4590,12 +4624,13 @@ int HAMLIB_API rig_set_split_freq(RIG *rig, vfo_t vfo, freq_t tx_freq) ENTERFUNC2; ELAPSED1; + rs = STATE(rig); + caps = rig->caps; + cachep = CACHE(rig); + rig_debug(RIG_DEBUG_VERBOSE, "%s called vfo=%s, curr_vfo=%s, tx_freq=%.0f\n", __func__, - rig_strvfo(vfo), rig_strvfo(rig->state.current_vfo), tx_freq); - - caps = rig->caps; - rs = STATE(rig); + rig_strvfo(vfo), rig_strvfo(rs->current_vfo), tx_freq); // Always use the previously selected TX VFO for split. The targeted VFO will have no effect. tx_vfo = rs->tx_vfo; @@ -4765,7 +4800,7 @@ int HAMLIB_API rig_get_split_freq(RIG *rig, vfo_t vfo, freq_t *tx_freq) { const struct rig_caps *caps; const struct rig_state *rs; - struct rig_cache *cachep = CACHE(rig); + struct rig_cache *cachep; int retcode = -RIG_EPROTO, rc2; vfo_t tx_vfo; @@ -4786,6 +4821,7 @@ int HAMLIB_API rig_get_split_freq(RIG *rig, vfo_t vfo, freq_t *tx_freq) caps = rig->caps; rs = STATE(rig); + cachep = CACHE(rig); // Always use the previously selected TX VFO for split. The targeted VFO will have no effect. tx_vfo = rs->tx_vfo; @@ -4944,7 +4980,7 @@ int HAMLIB_API rig_set_split_mode(RIG *rig, { const struct rig_caps *caps; const struct rig_state *rs; - struct rig_cache *cachep = CACHE(rig); + struct rig_cache *cachep; int retcode, rc2; vfo_t curr_vfo, tx_vfo, rx_vfo; freq_t cache_freq; @@ -4963,6 +4999,7 @@ int HAMLIB_API rig_set_split_mode(RIG *rig, caps = rig->caps; rs = STATE(rig); + cachep = CACHE(rig); // Always use the previously selected TX VFO for split. The targeted VFO will have no effect. tx_vfo = rs->tx_vfo; @@ -5179,7 +5216,7 @@ int HAMLIB_API rig_get_split_mode(RIG *rig, vfo_t vfo, rmode_t *tx_mode, { const struct rig_caps *caps; const struct rig_state *rs; - struct rig_cache *cachep = CACHE(rig); + struct rig_cache *cachep; int retcode, rc2; vfo_t curr_vfo, tx_vfo; @@ -5200,6 +5237,7 @@ int HAMLIB_API rig_get_split_mode(RIG *rig, vfo_t vfo, rmode_t *tx_mode, caps = rig->caps; rs = STATE(rig); + cachep = CACHE(rig); // Always use the previously selected TX VFO for split. The targeted VFO will have no effect. tx_vfo = rs->tx_vfo; @@ -5346,7 +5384,7 @@ int HAMLIB_API rig_set_split_freq_mode(RIG *rig, const struct rig_caps *caps; const struct rig_state *rs; vfo_t tx_vfo; - struct rig_cache *cachep = CACHE(rig); + struct rig_cache *cachep; int retcode; if (CHECK_RIG_ARG(rig)) @@ -5360,6 +5398,7 @@ int HAMLIB_API rig_set_split_freq_mode(RIG *rig, caps = rig->caps; rs = STATE(rig); + cachep = CACHE(rig); // Always use the previously selected TX VFO for split. The targeted VFO will have no effect. tx_vfo = rs->tx_vfo; @@ -5486,7 +5525,7 @@ int HAMLIB_API rig_get_split_freq_mode(RIG *rig, { const struct rig_caps *caps; const struct rig_state *rs; - struct rig_cache *cachep = CACHE(rig); + struct rig_cache *cachep; vfo_t tx_vfo; int retcode; @@ -5507,6 +5546,7 @@ int HAMLIB_API rig_get_split_freq_mode(RIG *rig, caps = rig->caps; rs = STATE(rig); + cachep = CACHE(rig); // Always use the previously selected TX VFO for split. The targeted VFO will have no effect. tx_vfo = rs->tx_vfo; @@ -5571,7 +5611,7 @@ int HAMLIB_API rig_set_split_vfo(RIG *rig, vfo_t tx_vfo) { const struct rig_caps *caps; - struct rig_cache *cachep = CACHE(rig); + struct rig_cache *cachep; int retcode; struct rig_state *rs; vfo_t curr_vfo; @@ -5582,15 +5622,16 @@ int HAMLIB_API rig_set_split_vfo(RIG *rig, return -RIG_EINVAL; } + caps = rig->caps; + rs = STATE(rig); + cachep = CACHE(rig); + ELAPSED1; ENTERFUNC; rig_debug(RIG_DEBUG_VERBOSE, "%s: rx_vfo=%s, split=%d, tx_vfo=%s, cache.split=%d\n", __func__, rig_strvfo(rx_vfo), split, rig_strvfo(tx_vfo), cachep->split); - caps = rig->caps; - rs = STATE(rig); - if (caps->set_split_vfo == NULL) { ELAPSED2; @@ -5822,7 +5863,7 @@ int HAMLIB_API rig_get_split_vfo(RIG *rig, { const struct rig_caps *caps; struct rig_state *rs; - struct rig_cache *cachep = CACHE(rig); + struct rig_cache *cachep; int retcode; int cache_ms; int use_cache = 0; @@ -5846,6 +5887,7 @@ int HAMLIB_API rig_get_split_vfo(RIG *rig, caps = rig->caps; rs = STATE(rig); + cachep = CACHE(rig); if (MUTEX_CHECK(&morse_mutex)) { @@ -5935,7 +5977,7 @@ int HAMLIB_API rig_set_rit(RIG *rig, vfo_t vfo, shortfreq_t rit) if ((caps->targetable_vfo & RIG_TARGETABLE_RITXIT) || vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == STATE(rig)->current_vfo) { HAMLIB_TRACE; retcode = caps->set_rit(rig, vfo, rit); @@ -5947,7 +5989,7 @@ int HAMLIB_API rig_set_rit(RIG *rig, vfo_t vfo, shortfreq_t rit) RETURNFUNC(-RIG_ENAVAIL); } - curr_vfo = rig->state.current_vfo; + curr_vfo = STATE(rig)->current_vfo; HAMLIB_TRACE; retcode = caps->set_vfo(rig, vfo); @@ -6012,7 +6054,7 @@ int HAMLIB_API rig_get_rit(RIG *rig, vfo_t vfo, shortfreq_t *rit) if ((caps->targetable_vfo & RIG_TARGETABLE_RITXIT) || vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == STATE(rig)->current_vfo) { HAMLIB_TRACE; retcode = caps->get_rit(rig, vfo, rit); @@ -6024,7 +6066,7 @@ int HAMLIB_API rig_get_rit(RIG *rig, vfo_t vfo, shortfreq_t *rit) RETURNFUNC(-RIG_ENAVAIL); } - curr_vfo = rig->state.current_vfo; + curr_vfo = STATE(rig)->current_vfo; HAMLIB_TRACE; retcode = caps->set_vfo(rig, vfo); @@ -6085,7 +6127,7 @@ int HAMLIB_API rig_set_xit(RIG *rig, vfo_t vfo, shortfreq_t xit) if ((caps->targetable_vfo & RIG_TARGETABLE_RITXIT) || vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == STATE(rig)->current_vfo) { HAMLIB_TRACE; retcode = caps->set_xit(rig, vfo, xit); @@ -6097,7 +6139,7 @@ int HAMLIB_API rig_set_xit(RIG *rig, vfo_t vfo, shortfreq_t xit) RETURNFUNC(-RIG_ENAVAIL); } - curr_vfo = rig->state.current_vfo; + curr_vfo = STATE(rig)->current_vfo; HAMLIB_TRACE; retcode = caps->set_vfo(rig, vfo); @@ -6162,7 +6204,7 @@ int HAMLIB_API rig_get_xit(RIG *rig, vfo_t vfo, shortfreq_t *xit) if ((caps->targetable_vfo & RIG_TARGETABLE_RITXIT) || vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == STATE(rig)->current_vfo) { HAMLIB_TRACE; retcode = caps->get_xit(rig, vfo, xit); @@ -6174,7 +6216,7 @@ int HAMLIB_API rig_get_xit(RIG *rig, vfo_t vfo, shortfreq_t *xit) RETURNFUNC(-RIG_ENAVAIL); } - curr_vfo = rig->state.current_vfo; + curr_vfo = STATE(rig)->current_vfo; HAMLIB_TRACE; retcode = caps->set_vfo(rig, vfo); @@ -6234,7 +6276,7 @@ int HAMLIB_API rig_set_ts(RIG *rig, vfo_t vfo, shortfreq_t ts) } if (vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == STATE(rig)->current_vfo) { HAMLIB_TRACE; retcode = caps->set_ts(rig, vfo, ts); @@ -6246,7 +6288,7 @@ int HAMLIB_API rig_set_ts(RIG *rig, vfo_t vfo, shortfreq_t ts) RETURNFUNC(-RIG_ENAVAIL); } - curr_vfo = rig->state.current_vfo; + curr_vfo = STATE(rig)->current_vfo; HAMLIB_TRACE; retcode = caps->set_vfo(rig, vfo); @@ -6311,7 +6353,7 @@ int HAMLIB_API rig_get_ts(RIG *rig, vfo_t vfo, shortfreq_t *ts) } if (vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == STATE(rig)->current_vfo) { HAMLIB_TRACE; retcode = caps->get_ts(rig, vfo, ts); @@ -6323,7 +6365,7 @@ int HAMLIB_API rig_get_ts(RIG *rig, vfo_t vfo, shortfreq_t *ts) RETURNFUNC(-RIG_ENAVAIL); } - curr_vfo = rig->state.current_vfo; + curr_vfo = STATE(rig)->current_vfo; HAMLIB_TRACE; retcode = caps->set_vfo(rig, vfo); @@ -6389,7 +6431,7 @@ int HAMLIB_API rig_set_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t option) if ((caps->targetable_vfo & RIG_TARGETABLE_ANT) || vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == STATE(rig)->current_vfo) { HAMLIB_TRACE; retcode = caps->set_ant(rig, vfo, ant, option); @@ -6401,7 +6443,7 @@ int HAMLIB_API rig_set_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t option) RETURNFUNC(-RIG_ENAVAIL); } - curr_vfo = rig->state.current_vfo; + curr_vfo = STATE(rig)->current_vfo; HAMLIB_TRACE; retcode = caps->set_vfo(rig, vfo); @@ -6483,7 +6525,7 @@ int HAMLIB_API rig_get_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t *option, if ((caps->targetable_vfo & RIG_TARGETABLE_ANT) || vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == STATE(rig)->current_vfo) { HAMLIB_TRACE; retcode = caps->get_ant(rig, vfo, ant, option, ant_curr, ant_tx, ant_rx); @@ -6495,7 +6537,7 @@ int HAMLIB_API rig_get_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t *option, RETURNFUNC(-RIG_ENAVAIL); } - curr_vfo = rig->state.current_vfo; + curr_vfo = STATE(rig)->current_vfo; HAMLIB_TRACE; retcode = caps->set_vfo(rig, vfo); @@ -6562,7 +6604,7 @@ int HAMLIB_API rig_power2mW(RIG *rig, RETURNFUNC(rig->caps->power2mW(rig, mwpower, power, freq, mode)); } - txrange = rig_get_range(rig->state.tx_range_list, freq, mode); + txrange = rig_get_range(STATE(rig)->tx_range_list, freq, mode); // check all the range lists if (txrange == NULL) { txrange = rig_get_range(rig->caps->tx_range_list1, freq, mode); } @@ -6634,7 +6676,7 @@ int HAMLIB_API rig_mW2power(RIG *rig, RETURNFUNC2(rig->caps->mW2power(rig, power, mwpower, freq, mode)); } - txrange = rig_get_range(rig->state.tx_range_list, freq, mode); + txrange = rig_get_range(STATE(rig)->tx_range_list, freq, mode); if (!txrange) { @@ -6738,7 +6780,7 @@ int HAMLIB_API rig_set_powerstat(RIG *rig, powerstat_t status) if (rig->caps->set_powerstat == NULL) { rig_debug(RIG_DEBUG_WARN, "%s set_powerstat not implemented\n", __func__); - rig->state.powerstat = + STATE(rig)->powerstat = RIG_POWER_ON; // assume we are on if we can't set_powerstat RETURNFUNC(-RIG_ENAVAIL); } @@ -6748,7 +6790,7 @@ int HAMLIB_API rig_set_powerstat(RIG *rig, powerstat_t status) if (retcode == RIG_OK) { - rig->state.powerstat = status; + STATE(rig)->powerstat = status; } // if anything is queued up flush it @@ -6801,7 +6843,7 @@ int HAMLIB_API rig_get_powerstat(RIG *rig, powerstat_t *status) if (retcode == RIG_OK) { - rig->state.powerstat = *status; + STATE(rig)->powerstat = *status; } else { @@ -6940,7 +6982,7 @@ vfo_op_t HAMLIB_API rig_has_vfo_op(RIG *rig, vfo_op_t op) ENTERFUNC; - retcode = rig->state.vfo_ops & op; + retcode = STATE(rig)->vfo_ops & op; RETURNFUNC(retcode); } @@ -6987,7 +7029,7 @@ int HAMLIB_API rig_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op) } if (vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == STATE(rig)->current_vfo) { retcode = caps->vfo_op(rig, vfo, op); ELAPSED2; @@ -7001,7 +7043,7 @@ int HAMLIB_API rig_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op) RETURNFUNC(-RIG_ENAVAIL); } - curr_vfo = rig->state.current_vfo; + curr_vfo = STATE(rig)->current_vfo; HAMLIB_TRACE; retcode = caps->set_vfo(rig, vfo); @@ -7099,7 +7141,7 @@ int HAMLIB_API rig_scan(RIG *rig, vfo_t vfo, scan_t scan, int ch) } if (vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == STATE(rig)->current_vfo) { retcode = caps->scan(rig, vfo, scan, ch); RETURNFUNC(retcode); @@ -7110,7 +7152,7 @@ int HAMLIB_API rig_scan(RIG *rig, vfo_t vfo, scan_t scan, int ch) RETURNFUNC(-RIG_ENAVAIL); } - curr_vfo = rig->state.current_vfo; + curr_vfo = STATE(rig)->current_vfo; HAMLIB_TRACE; retcode = caps->set_vfo(rig, vfo); @@ -7175,7 +7217,7 @@ int HAMLIB_API rig_send_dtmf(RIG *rig, vfo_t vfo, const char *digits) } if (vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == STATE(rig)->current_vfo) { retcode = caps->send_dtmf(rig, vfo, digits); RETURNFUNC(retcode); @@ -7186,7 +7228,7 @@ int HAMLIB_API rig_send_dtmf(RIG *rig, vfo_t vfo, const char *digits) RETURNFUNC(-RIG_ENAVAIL); } - curr_vfo = rig->state.current_vfo; + curr_vfo = STATE(rig)->current_vfo; HAMLIB_TRACE; retcode = caps->set_vfo(rig, vfo); @@ -7252,7 +7294,7 @@ int HAMLIB_API rig_recv_dtmf(RIG *rig, vfo_t vfo, char *digits, int *length) } if (vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == STATE(rig)->current_vfo) { retcode = caps->recv_dtmf(rig, vfo, digits, length); RETURNFUNC(retcode); @@ -7263,7 +7305,7 @@ int HAMLIB_API rig_recv_dtmf(RIG *rig, vfo_t vfo, char *digits, int *length) RETURNFUNC(-RIG_ENAVAIL); } - curr_vfo = rig->state.current_vfo; + curr_vfo = STATE(rig)->current_vfo; HAMLIB_TRACE; retcode = caps->set_vfo(rig, vfo); @@ -7304,6 +7346,7 @@ int HAMLIB_API rig_recv_dtmf(RIG *rig, vfo_t vfo, char *digits, int *length) int HAMLIB_API rig_send_morse(RIG *rig, vfo_t vfo, const char *msg) { const struct rig_caps *caps; + struct rig_state *rs; int retcode = RIG_EINTERNAL, rc2; vfo_t curr_vfo; @@ -7314,6 +7357,7 @@ int HAMLIB_API rig_send_morse(RIG *rig, vfo_t vfo, const char *msg) } ENTERFUNC; + rs = STATE(rig); if (!msg) { @@ -7345,14 +7389,14 @@ int HAMLIB_API rig_send_morse(RIG *rig, vfo_t vfo, const char *msg) } if (vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == rs->current_vfo) { #if 0 LOCK(1); retcode = caps->send_morse(rig, vfo, msg); LOCK(0); #endif - push(rig->state.fifo_morse, msg); + push(rs->fifo_morse, msg); RETURNFUNC(RIG_OK); } @@ -7361,7 +7405,7 @@ int HAMLIB_API rig_send_morse(RIG *rig, vfo_t vfo, const char *msg) RETURNFUNC(-RIG_ENAVAIL); } - curr_vfo = rig->state.current_vfo; + curr_vfo = rs->current_vfo; retcode = caps->set_vfo(rig, vfo); if (retcode != RIG_OK) @@ -7398,6 +7442,7 @@ int HAMLIB_API rig_send_morse(RIG *rig, vfo_t vfo, const char *msg) int HAMLIB_API rig_stop_morse(RIG *rig, vfo_t vfo) { const struct rig_caps *caps; + struct rig_state *rs; int retcode, rc2; vfo_t curr_vfo; @@ -7410,16 +7455,17 @@ int HAMLIB_API rig_stop_morse(RIG *rig, vfo_t vfo) ENTERFUNC; caps = rig->caps; + rs = STATE(rig); if (caps->stop_morse == NULL) { RETURNFUNC(-RIG_ENAVAIL); } - resetFIFO(rig->state.fifo_morse); // clear out the CW queue + resetFIFO(rs->fifo_morse); // clear out the CW queue if (vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == rs->current_vfo) { RETURNFUNC(caps->stop_morse(rig, vfo)); } @@ -7429,7 +7475,7 @@ int HAMLIB_API rig_stop_morse(RIG *rig, vfo_t vfo) RETURNFUNC(-RIG_ENAVAIL); } - curr_vfo = rig->state.current_vfo; + curr_vfo = rs->current_vfo; HAMLIB_TRACE; retcode = caps->set_vfo(rig, vfo); @@ -7519,7 +7565,7 @@ int HAMLIB_API rig_wait_morse(RIG *rig, vfo_t vfo) caps = rig->caps; if (vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == STATE(rig)->current_vfo) { RETURNFUNC(wait_morse_ptt(rig, vfo)); } @@ -7529,7 +7575,7 @@ int HAMLIB_API rig_wait_morse(RIG *rig, vfo_t vfo) RETURNFUNC(-RIG_ENAVAIL); } - curr_vfo = rig->state.current_vfo; + curr_vfo = STATE(rig)->current_vfo; HAMLIB_TRACE; retcode = caps->set_vfo(rig, vfo); @@ -7589,7 +7635,7 @@ int HAMLIB_API rig_send_voice_mem(RIG *rig, vfo_t vfo, int ch) } if (vfo == RIG_VFO_CURR - || vfo == rig->state.current_vfo) + || vfo == STATE(rig)->current_vfo) { retcode = caps->send_voice_mem(rig, vfo, ch); RETURNFUNC(retcode); @@ -7600,7 +7646,7 @@ int HAMLIB_API rig_send_voice_mem(RIG *rig, vfo_t vfo, int ch) RETURNFUNC(-RIG_ENAVAIL); } - curr_vfo = rig->state.current_vfo; + curr_vfo = STATE(rig)->current_vfo; HAMLIB_TRACE; retcode = caps->set_vfo(rig, vfo); @@ -7728,7 +7774,7 @@ int HAMLIB_API rig_set_vfo_opt(RIG *rig, int status) if (rig->caps->set_vfo_opt == NULL) { ELAPSED2; - rig->state.vfo_opt = status; + STATE(rig)->vfo_opt = status; //RETURNFUNC(-RIG_ENAVAIL); RETURNFUNC(RIG_OK); } @@ -7825,7 +7871,7 @@ int HAMLIB_API rig_get_rig_info(RIG *rig, char *response, int max_response_len) int satmode; int ret; int rxa, txa, rxb, txb; - struct rig_cache *cachep = CACHE(rig); + struct rig_cache *cachep; if (CHECK_RIG_ARG(rig) || !response) { @@ -7833,6 +7879,8 @@ int HAMLIB_API rig_get_rig_info(RIG *rig, char *response, int max_response_len) return -RIG_EINVAL; } + cachep = CACHE(rig); + response[0] = 0; ELAPSED1; ENTERFUNC2; @@ -7922,7 +7970,7 @@ int HAMLIB_API rig_get_vfo_info(RIG *rig, vfo_t vfo, freq_t *freq, rmode_t *mode, pbwidth_t *width, split_t *split, int *satmode) { int retval; - struct rig_cache *cachep = CACHE(rig); + struct rig_cache *cachep; rig_debug(RIG_DEBUG_VERBOSE, "%s called vfo=%s\n", __func__, rig_strvfo(vfo)); @@ -7932,10 +7980,12 @@ int HAMLIB_API rig_get_vfo_info(RIG *rig, vfo_t vfo, freq_t *freq, return -RIG_EINVAL; } + cachep = CACHE(rig); + ELAPSED1; ENTERFUNC; - //if (vfo == RIG_VFO_CURR) { vfo = rig->state.current_vfo; } + //if (vfo == RIG_VFO_CURR) { vfo = STATE(rig)->current_vfo; } vfo = vfo_fixup(rig, vfo, cachep->split); // we can't use the cached values as some clients may only call this function @@ -8007,7 +8057,7 @@ int HAMLIB_API rig_get_vfo_list(RIG *rig, char *buf, int buflen) ENTERFUNC; - rig_sprintf_vfo(buf, buflen - 1, rig->state.vfo_list); + rig_sprintf_vfo(buf, buflen - 1, STATE(rig)->vfo_list); RETURNFUNC(RIG_OK); } @@ -8255,23 +8305,24 @@ void rig_lock(RIG *rig, int lock) { #if defined(HAVE_PTHREAD) - if (rig->state.multicast == NULL) { return; } // not initialized yet + struct rig_state *rs = STATE(rig); + if (rs->multicast == NULL) { return; } // not initialized yet - if (!rig->state.multicast->mutex_initialized) + if (!rs->multicast->mutex_initialized) { - rig->state.multicast->mutex = initializer; - rig->state.multicast->mutex_initialized = 1; + rs->multicast->mutex = initializer; + rs->multicast->mutex_initialized = 1; } if (lock) { - pthread_mutex_lock(&rig->state.multicast->mutex); + pthread_mutex_lock(&rs->multicast->mutex); rig_debug(RIG_DEBUG_VERBOSE, "%s: client lock engaged\n", __func__); } else { rig_debug(RIG_DEBUG_VERBOSE, "%s: client lock disengaged\n", __func__); - pthread_mutex_unlock(&rig->state.multicast->mutex); + pthread_mutex_unlock(&rs->multicast->mutex); } #endif @@ -8580,7 +8631,7 @@ void *morse_data_handler(void *arg) c = calloc(1, qsize + 1); - while (rs->morse_data_handler_thread_run || (peek(rig->state.fifo_morse) >= 0)) + while (rs->morse_data_handler_thread_run || (peek(rs->fifo_morse) >= 0)) { int n = 0; memset(c, 0, qsize); @@ -8836,7 +8887,7 @@ HAMLIB_EXPORT(int) rig_set_lock_mode(RIG *rig, int mode) } else { - rig->state.lock_mode = mode; + STATE(rig)->lock_mode = mode; retcode = RIG_OK; } @@ -8853,7 +8904,7 @@ HAMLIB_EXPORT(int) rig_get_lock_mode(RIG *rig, int *mode) } else { - *mode = rig->state.lock_mode; + *mode = STATE(rig)->lock_mode; retcode = RIG_OK; } From 37321a1df898022e0c2020839ca91c99a90a8e9c Mon Sep 17 00:00:00 2001 From: George Baltz N3GB Date: Tue, 2 Jul 2024 13:17:26 -0400 Subject: [PATCH 4/4] Play catch-up with recent code. --- rigs/commradio/commradio.c | 9 +++++---- rigs/dummy/rot_pstrotator.c | 2 +- rigs/tentec/orion.c | 2 +- rigs/yaesu/pmr171.c | 28 ++++++++++++++-------------- src/conf.c | 4 ++-- tests/rigmem.c | 7 ++++--- 6 files changed, 27 insertions(+), 25 deletions(-) diff --git a/rigs/commradio/commradio.c b/rigs/commradio/commradio.c index 852aedc1b..888db0f2c 100644 --- a/rigs/commradio/commradio.c +++ b/rigs/commradio/commradio.c @@ -28,31 +28,32 @@ int commradio_transaction(RIG *rig, const unsigned char *cmd, int cmd_len, { int ret = -RIG_EINTERNAL; struct rig_state *rs; + hamlib_port_t *rp = RIGPORT(rig); ENTERFUNC; - rs = &rig->state; + rs = STATE(rig); rs->transaction_active = 1; /* * Flush is needed until async mode is done. The CTX-10 sends frames every * time the VFO changes. */ - rig_flush(&rs->rigport); + rig_flush(rp); int frame_len; unsigned char frame[3+2*(cmd_len+2)]; size_t rx_len = CR_FRAMELENGTH; unsigned char rx[rx_len]; frame_len = frame_message(frame, cmd, cmd_len); - ret = write_block(&rs->rigport, frame, frame_len); + ret = write_block(rp, frame, frame_len); if (ret < RIG_OK) { goto transaction_quit; } const char stopset[] = { CR_EOF }; - ret = read_string(&rs->rigport, rx, rx_len-1, stopset, 1, 0, 1); + ret = read_string(rp, rx, rx_len-1, stopset, 1, 0, 1); if (ret < RIG_OK) { goto transaction_quit; diff --git a/rigs/dummy/rot_pstrotator.c b/rigs/dummy/rot_pstrotator.c index 7beb58065..f45e92791 100644 --- a/rigs/dummy/rot_pstrotator.c +++ b/rigs/dummy/rot_pstrotator.c @@ -353,7 +353,7 @@ static int pstrotator_rot_close(ROT *rot) priv = (struct pstrotator_rot_priv_data *)ROTSTATE(rot)->priv; pstrotator_handler_priv_data *pstrotator_handler_priv; pstrotator_handler_priv = (pstrotator_handler_priv_data *) - rot->state.pstrotator_handler_priv_data; + ROTSTATE(rot)->pstrotator_handler_priv_data; rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); diff --git a/rigs/tentec/orion.c b/rigs/tentec/orion.c index 26c275ba3..b52040ff0 100644 --- a/rigs/tentec/orion.c +++ b/rigs/tentec/orion.c @@ -793,7 +793,7 @@ int tt565_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width) char ttmode, ttreceiver; int retry; int timeout; - int widthOld = rig->state.cache.widthMainA; + int widthOld = CACHE(rig)->widthMainA; struct rig_state *rs = STATE(rig); ttreceiver = which_receiver(rig, vfo); diff --git a/rigs/yaesu/pmr171.c b/rigs/yaesu/pmr171.c index c2c8b9ad8..2b4c7f966 100644 --- a/rigs/yaesu/pmr171.c +++ b/rigs/yaesu/pmr171.c @@ -403,8 +403,8 @@ static int pmr171_init(RIG *rig) return -RIG_ENOMEM; } - rig->state.cache.freqMainA = 14999000; - rig->state.cache.freqMainB = 14999000; + CACHE(rig)->freqMainA = 14999000; + CACHE(rig)->freqMainB = 14999000; return RIG_OK; } @@ -475,7 +475,7 @@ static int pmr171_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) // probably already read VFO_A so just return cache for VFO_B for now if (vfo == RIG_VFO_B) { - *freq = rig->state.cache.freqMainB; + *freq = cachep->freqMainB; return RIG_OK; } @@ -484,16 +484,16 @@ static int pmr171_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) read_block(rp, &reply[5], reply[4]); vfoa = from_bcd_be(&reply[9], 8); vfob = from_bcd_be(&reply[13], 8); - rig->state.cache.freqMainA = vfoa; - rig->state.cache.freqMainB = vfob; + cachep->freqMainA = vfoa; + cachep->freqMainB = vfob; rig_debug(RIG_DEBUG_VERBOSE, "%s: vfoa=%.0f, vfob=%.0f\n", __func__, vfoa, vfob); // Now grab the ptt status - rig->state.cache.ptt = reply[6] == 1; + cachep->ptt = reply[6] == 1; // And the mode - rig->state.cache.modeMainA = pmr171_modes[reply[7]]; - rig->state.cache.modeMainB = pmr171_modes[reply[8]]; + cachep->modeMainA = pmr171_modes[reply[7]]; + cachep->modeMainB = pmr171_modes[reply[8]]; if (vfo == RIG_VFO_B) { *freq = cachep->freqMainA; } else { *freq = cachep->freqMainB; } @@ -514,7 +514,7 @@ static int pmr171_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width) static int pmr171_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split, vfo_t *tx_vfo) { - *split = rig->state.cache.split; + *split = CACHE(rig)->split; if (*split) *tx_vfo=RIG_VFO_B; else *tx_vfo = RIG_VFO_A; return RIG_OK; @@ -524,7 +524,7 @@ static int pmr171_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt) { //struct pmr171_priv_data *p = (struct pmr171_priv_data *) STATE(rig)->priv; rig_debug(RIG_DEBUG_VERBOSE, "%s: called\n", __func__); - *ptt = rig->state.cache.ptt; + *ptt = CACHE(rig)->ptt; return RIG_OK; } @@ -795,13 +795,13 @@ static int pmr171_set_freq(RIG *rig, vfo_t vfo, freq_t freq) /* fill in the frequency */ if (vfo == RIG_VFO_B) { - to_bcd_be(&cmd[6], rig->state.cache.freqMainA, 8); + to_bcd_be(&cmd[6], CACHE(rig)->freqMainA, 8); to_bcd_be(&cmd[10], freq, 8); } else { to_bcd_be(&cmd[6], freq, 8); - to_bcd_be(&cmd[10], rig->state.cache.freqMainB, 8); + to_bcd_be(&cmd[10], CACHE(rig)->freqMainB, 8); } unsigned int crc = CRC16Check(&cmd[4], 12); @@ -828,13 +828,13 @@ static int pmr171_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) { if (vfo == RIG_VFO_B) { - cmd[6] = rig->state.cache.modeMainA; + cmd[6] = CACHE(rig)->modeMainA; cmd[7] = i; } else { cmd[6] = i; - cmd[7] = rig->state.cache.modeMainB; + cmd[7] = CACHE(rig)->modeMainB; } crc = CRC16Check(&cmd[4], 4); diff --git a/src/conf.c b/src/conf.c index c54a8f6f0..7f84144d2 100644 --- a/src/conf.c +++ b/src/conf.c @@ -266,8 +266,8 @@ static int frontend_set_conf(RIG *rig, hamlib_token_t token, const char *val) rig_debug(RIG_DEBUG_WARN, "%s: overriding port and changing to 4992\n", __func__); } sprintf(rs->rigport_deprecated.pathname, "%s:%s", val2, "4992"); - strcpy(rs->rigport.pathname,rs->rigport_deprecated.pathname); - rig_debug(RIG_DEBUG_WARN, "%s: pathname=%s\n", __func__, rs->rigport.pathname); + strcpy(rp->pathname, rs->rigport_deprecated.pathname); + rig_debug(RIG_DEBUG_WARN, "%s: pathname=%s\n", __func__, rp->pathname); free(val2); } else diff --git a/tests/rigmem.c b/tests/rigmem.c index 23fe12c28..79a647d59 100644 --- a/tests/rigmem.c +++ b/tests/rigmem.c @@ -489,6 +489,7 @@ int clear_chans(RIG *rig, const char *infilename) { int i, j, ret; channel_t chan; + struct rig_state *rs = STATE(rig); memset(&chan, 0, sizeof(chan)); chan.freq = RIG_FREQ_NONE; @@ -497,10 +498,10 @@ int clear_chans(RIG *rig, const char *infilename) chan.tx_mode = RIG_MODE_NONE; chan.vfo = RIG_VFO_MEM; - for (i = 0; rig->state.chan_list[i].type; i++) + for (i = 0; rs->chan_list[i].type; i++) { - for (j = rig->state.chan_list[i].startc; - j <= rig->state.chan_list[i].endc; j++) + for (j = rs->chan_list[i].startc; + j <= rs->chan_list[i].endc; j++) { chan.channel_num = j;