mirror
/
Hamlib
kopia lustrzana https://github.com/Hamlib/Hamlib
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

Balance ENTERFUNC/RETURNFUNC, ENTERFUNC2/RETURNFUNC2, ELAPSED1/ELAPSED2 usage 

See that each call to the above is matched by a call to its counterpart.  Most
are cosmetic (now) but EF/RF mismatches make the depth wrong.

Plus the rig->state pointerizations I started this with.
pull/1570/head
George Baltz N3GB 2024-06-19 14:28:28 -04:00
rodzic da4f9fbc3e
commit cd135de590
1 zmienionych plików z 42 dodań i 32 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

74
src/rig.c
Wyświetl plik

@ -1140,7 +1140,7 @@ int HAMLIB_API rig_open(RIG *rig)
rig_debug(RIG_DEBUG_VERBOSE, "%s: rs->comm_state==0?=%d\n", __func__, rig_debug(RIG_DEBUG_VERBOSE, "%s: rs->comm_state==0?=%d\n", __func__,
rs->comm_state); rs->comm_state);
rs->comm_state = 0; rs->comm_state = 0;
rig->state.comm_status = RIG_COMM_STATUS_ERROR; rs->comm_status = RIG_COMM_STATUS_ERROR;
RETURNFUNC2(status); RETURNFUNC2(status);
} }
@ -1358,7 +1358,7 @@ int HAMLIB_API rig_open(RIG *rig)
if (status < 0) if (status < 0)
{ {
port_close(rp, rp->type.rig); port_close(rp, rp->type.rig);
rig->state.comm_status = RIG_COMM_STATUS_ERROR; rs->comm_status = RIG_COMM_STATUS_ERROR;
RETURNFUNC2(status); RETURNFUNC2(status);
} }
@ -1371,7 +1371,7 @@ int HAMLIB_API rig_open(RIG *rig)
if (status < 0) if (status < 0)
{ {
port_close(rp, rp->type.rig); port_close(rp, rp->type.rig);
rig->state.comm_status = RIG_COMM_STATUS_ERROR; rs->comm_status = RIG_COMM_STATUS_ERROR;
RETURNFUNC2(status); RETURNFUNC2(status);
} }
} }
@ -1402,7 +1402,7 @@ int HAMLIB_API rig_open(RIG *rig)
if (status == RIG_OK && (powerflag == RIG_POWER_OFF if (status == RIG_OK && (powerflag == RIG_POWER_OFF
|| powerflag == RIG_POWER_STANDBY) || powerflag == RIG_POWER_STANDBY)
&& rig->state.auto_power_on == 0) && rs->auto_power_on == 0)
{ {
// rig_open() should succeed even if the rig is powered off, so simply log power status // rig_open() should succeed even if the rig is powered off, so simply log power status
rig_debug(RIG_DEBUG_ERR, rig_debug(RIG_DEBUG_ERR,
@ -1440,7 +1440,7 @@ int HAMLIB_API rig_open(RIG *rig)
port_close(rp, rp->type.rig); port_close(rp, rp->type.rig);
memcpy(&rs->rigport_deprecated, rp, sizeof(hamlib_port_t_deprecated)); memcpy(&rs->rigport_deprecated, rp, sizeof(hamlib_port_t_deprecated));
rs->comm_state = 0; rs->comm_state = 0;
rig->state.comm_status = RIG_COMM_STATUS_ERROR; rs->comm_status = RIG_COMM_STATUS_ERROR;
RETURNFUNC2(status); RETURNFUNC2(status);
} }
} }
@ -1478,7 +1478,7 @@ int HAMLIB_API rig_open(RIG *rig)
} }
} }
if (skip_init) { return RIG_OK; } if (skip_init) { RETURNFUNC2(RIG_OK); }
#if defined(HAVE_PTHREAD) #if defined(HAVE_PTHREAD)
// Some models don't support CW so don't need morse handler // Some models don't support CW so don't need morse handler
@ -1560,10 +1560,10 @@ int HAMLIB_API rig_open(RIG *rig)
memcpy(&rs->rigport_deprecated, rp, sizeof(hamlib_port_t_deprecated)); memcpy(&rs->rigport_deprecated, rp, sizeof(hamlib_port_t_deprecated));
memcpy(&rs->pttport_deprecated, pttp, sizeof(hamlib_port_t_deprecated)); memcpy(&rs->pttport_deprecated, pttp, sizeof(hamlib_port_t_deprecated));
memcpy(&rs->dcdport_deprecated, dcdp, sizeof(hamlib_port_t_deprecated)); memcpy(&rs->dcdport_deprecated, dcdp, sizeof(hamlib_port_t_deprecated));
int timesave = rig->state.timeout; int timesave = rs->timeout;
rig->state.timeout = 0; rs->timeout = 0;
rig_flush_force(rp, 1); rig_flush_force(rp, 1);
rig->state.timeout = timesave; rs->timeout = timesave;
#if defined(HAVE_PTHREAD) #if defined(HAVE_PTHREAD)
enum multicast_item_e items = RIG_MULTICAST_POLL | RIG_MULTICAST_TRANSCEIVE enum multicast_item_e items = RIG_MULTICAST_POLL | RIG_MULTICAST_TRANSCEIVE
@ -1601,7 +1601,7 @@ int HAMLIB_API rig_open(RIG *rig)
#endif #endif
rig->state.comm_status = RIG_COMM_STATUS_OK; rs->comm_status = RIG_COMM_STATUS_OK;
add_opened_rig(rig); add_opened_rig(rig);
@ -1916,9 +1916,11 @@ int HAMLIB_API rig_get_twiddle(RIG *rig, int *seconds)
static int twiddling(RIG *rig) static int twiddling(RIG *rig)
{ {
const struct rig_caps *caps; const struct rig_caps *caps;
struct rig_state *rs = STATE(rig);
if (rig->state.twiddle_timeout == 0) { return 0; } // don't detect twiddling if (rs->twiddle_timeout == 0) { return 0; } // don't detect twiddling
ENTERFUNC2;
caps = rig->caps; caps = rig->caps;
if (caps->get_freq) // gotta have get_freq of course if (caps->get_freq) // gotta have get_freq of course
@ -1930,31 +1932,31 @@ static int twiddling(RIG *rig)
HAMLIB_TRACE; HAMLIB_TRACE;
retval2 = caps->get_freq(rig, RIG_VFO_CURR, &curr_freq); retval2 = caps->get_freq(rig, RIG_VFO_CURR, &curr_freq);
if (retval2 == RIG_OK && rig->state.current_freq != curr_freq) if (retval2 == RIG_OK && rs->current_freq != curr_freq)
{ {
rig_debug(RIG_DEBUG_TRACE, rig_debug(RIG_DEBUG_TRACE,
"%s: Somebody twiddling the VFO? last_freq=%.0f, curr_freq=%.0f\n", __func__, "%s: Somebody twiddling the VFO? last_freq=%.0f, curr_freq=%.0f\n", __func__,
rig->state.current_freq, curr_freq); rs->current_freq, curr_freq);
if (rig->state.current_freq == 0) if (rs->current_freq == 0)
{ {
rig->state.current_freq = curr_freq; rs->current_freq = curr_freq;
RETURNFUNC2(0); // not twiddling as first time freq is being set RETURNFUNC2(0); // not twiddling as first time freq is being set
} }
rig->state.twiddle_time = time(NULL); // update last twiddle time rs->twiddle_time = time(NULL); // update last twiddle time
rig->state.current_freq = curr_freq; // we have a new freq to remember rs->current_freq = curr_freq; // we have a new freq to remember
rig_set_cache_freq(rig, RIG_VFO_CURR, curr_freq); rig_set_cache_freq(rig, RIG_VFO_CURR, curr_freq);
} }
elapsed = time(NULL) - rig->state.twiddle_time; elapsed = time(NULL) - rs->twiddle_time;
if (elapsed < rig->state.twiddle_timeout) if (elapsed < rs->twiddle_timeout)
{ {
rig_debug(RIG_DEBUG_TRACE, "%s: Twiddle elapsed < %d, elapsed=%d\n", __func__, rig_debug(RIG_DEBUG_TRACE, "%s: Twiddle elapsed < %d, elapsed=%d\n", __func__,
rig->state.twiddle_timeout, elapsed); rs->twiddle_timeout, elapsed);
rig->state.twiddle_state = TWIDDLE_ON; // gets turned off in rig_set_freq; rs->twiddle_state = TWIDDLE_ON; // gets turned off in rig_set_freq;
RETURNFUNC(1); // would be better as error but other software won't handle it RETURNFUNC2(1); // would be better as error but other software won't handle it
} }
} }
@ -2141,6 +2143,7 @@ int rig_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
if (skip_freq(rig, vfo)) if (skip_freq(rig, vfo))
{ {
ELAPSED2;
LOCK(0); LOCK(0);
RETURNFUNC(RIG_OK); RETURNFUNC(RIG_OK);
} }
@ -4443,11 +4446,10 @@ int HAMLIB_API rig_set_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t rptr_offs)
if (!caps->set_vfo) if (!caps->set_vfo)
{ {
ELAPSED2;
RETURNFUNC(-RIG_ENAVAIL); RETURNFUNC(-RIG_ENAVAIL);
} }
ELAPSED2;
curr_vfo = rig->state.current_vfo; curr_vfo = rig->state.current_vfo;
HAMLIB_TRACE; HAMLIB_TRACE;
retcode = caps->set_vfo(rig, vfo); retcode = caps->set_vfo(rig, vfo);
@ -4579,14 +4581,13 @@ int HAMLIB_API rig_set_split_freq(RIG *rig, vfo_t vfo, freq_t tx_freq)
vfo_t curr_vfo, tx_vfo = RIG_VFO_CURR; vfo_t curr_vfo, tx_vfo = RIG_VFO_CURR;
freq_t tfreq = 0; freq_t tfreq = 0;
ENTERFUNC2;
if (CHECK_RIG_ARG(rig)) if (CHECK_RIG_ARG(rig))
{ {
rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n", __func__); rig_debug(RIG_DEBUG_ERR, "%s: rig or rig->caps is null\n", __func__);
return -RIG_EINVAL; return -RIG_EINVAL;
} }
ENTERFUNC2;
ELAPSED1; ELAPSED1;
rig_debug(RIG_DEBUG_VERBOSE, "%s called vfo=%s, curr_vfo=%s, tx_freq=%.0f\n", rig_debug(RIG_DEBUG_VERBOSE, "%s called vfo=%s, curr_vfo=%s, tx_freq=%.0f\n",
@ -4654,7 +4655,7 @@ int HAMLIB_API rig_set_split_freq(RIG *rig, vfo_t vfo, freq_t tx_freq)
if (retcode != RIG_OK) if (retcode != RIG_OK)
{ {
RETURNFUNC(retcode); RETURNFUNC2(retcode);
} }
#if 0 // this verification seems to be causing bad behavior on some rigs #if 0 // this verification seems to be causing bad behavior on some rigs
@ -5016,7 +5017,7 @@ int HAMLIB_API rig_set_split_mode(RIG *rig,
RETURNFUNC(retcode); RETURNFUNC(retcode);
} }
curr_vfo = rig->state.current_vfo; curr_vfo = rs->current_vfo;
rig_debug(RIG_DEBUG_VERBOSE, "%s: curr_vfo=%s, tx_vfo=%s\n", __func__, rig_debug(RIG_DEBUG_VERBOSE, "%s: curr_vfo=%s, tx_vfo=%s\n", __func__,
rig_strvfo(curr_vfo), rig_strvfo(tx_vfo)); rig_strvfo(curr_vfo), rig_strvfo(tx_vfo));
@ -5600,7 +5601,7 @@ int HAMLIB_API rig_set_split_vfo(RIG *rig,
{ {
rig_debug(RIG_DEBUG_WARN, "%s: cannot execute when PTT is on\n", __func__); rig_debug(RIG_DEBUG_WARN, "%s: cannot execute when PTT is on\n", __func__);
ELAPSED2; ELAPSED2;
return RIG_OK; RETURNFUNC(RIG_OK);
} }
if (rx_vfo == RIG_VFO_NONE || tx_vfo == RIG_VFO_NONE) if (rx_vfo == RIG_VFO_NONE || tx_vfo == RIG_VFO_NONE)
@ -6623,9 +6624,11 @@ int HAMLIB_API rig_mW2power(RIG *rig,
if (!rig || !rig->caps || !power || mwpower == 0) if (!rig || !rig->caps || !power || mwpower == 0)
{ {
RETURNFUNC2(-RIG_EINVAL); return -RIG_EINVAL;
} }
ENTERFUNC2;
if (rig->caps->mW2power != NULL) if (rig->caps->mW2power != NULL)
{ {
RETURNFUNC2(rig->caps->mW2power(rig, power, mwpower, freq, mode)); RETURNFUNC2(rig->caps->mW2power(rig, power, mwpower, freq, mode));
@ -7832,6 +7835,7 @@ int HAMLIB_API rig_get_rig_info(RIG *rig, char *response, int max_response_len)
response[0] = 0; response[0] = 0;
ELAPSED1; ELAPSED1;
ENTERFUNC2;
vfoA = vfo_fixup(rig, RIG_VFO_A, cachep->split); vfoA = vfo_fixup(rig, RIG_VFO_A, cachep->split);
vfoB = vfo_fixup(rig, RIG_VFO_B, cachep->split); vfoB = vfo_fixup(rig, RIG_VFO_B, cachep->split);
@ -8015,6 +8019,7 @@ int HAMLIB_API rig_get_vfo_list(RIG *rig, char *buf, int buflen)
int HAMLIB_API rig_set_clock(RIG *rig, int year, int month, int day, int hour, int HAMLIB_API rig_set_clock(RIG *rig, int year, int month, int day, int hour,
int min, int sec, double msec, int utc_offset) int min, int sec, double msec, int utc_offset)
{ {
ENTERFUNC2;
if (rig->caps->set_clock == NULL) if (rig->caps->set_clock == NULL)
{ {
return -RIG_ENIMPL; return -RIG_ENIMPL;
@ -8039,6 +8044,7 @@ int HAMLIB_API rig_get_clock(RIG *rig, int *year, int *month, int *day,
return -RIG_ENIMPL; return -RIG_ENIMPL;
} }
ENTERFUNC2;
retval = rig->caps->get_clock(rig, year, month, day, hour, min, sec, retval = rig->caps->get_clock(rig, year, month, day, hour, min, sec,
msec, utc_offset); msec, utc_offset);
RETURNFUNC2(retval); RETURNFUNC2(retval);
@ -8735,7 +8741,8 @@ HAMLIB_EXPORT(int) rig_send_raw(RIG *rig, const unsigned char *send,
__func__, rig->caps->model_name); __func__, rig->caps->model_name);
memcpy(reply, send, send_len); memcpy(reply, send, send_len);
retval = send_len; retval = send_len;
return retval; ELAPSED2;
RETURNFUNC(retval);
} }
else else
{ {
@ -8784,6 +8791,7 @@ HAMLIB_EXPORT(int) rig_send_raw(RIG *rig, const unsigned char *send,
rig_debug(RIG_DEBUG_ERR, "%s: read_string, result=%d\n", __func__, retval); rig_debug(RIG_DEBUG_ERR, "%s: read_string, result=%d\n", __func__, retval);
rig_flush_force(rp, 1); rig_flush_force(rp, 1);
set_transaction_inactive(rig); set_transaction_inactive(rig);
ELAPSED2;
RETURNFUNC(retval); RETURNFUNC(retval);
} }
@ -8795,7 +8803,8 @@ HAMLIB_EXPORT(int) rig_send_raw(RIG *rig, const unsigned char *send,
__func__, reply_len, nbytes); __func__, reply_len, nbytes);
rig_flush_force(rp, 1); rig_flush_force(rp, 1);
set_transaction_inactive(rig); set_transaction_inactive(rig);
return -RIG_EINVAL; ELAPSED2;
RETURNFUNC(-RIG_EINVAL);
} }
} }
@ -8805,6 +8814,7 @@ HAMLIB_EXPORT(int) rig_send_raw(RIG *rig, const unsigned char *send,
{ {
rig_flush_force(rp, 1); rig_flush_force(rp, 1);
set_transaction_inactive(rig); set_transaction_inactive(rig);
ELAPSED2;
RETURNFUNC(retval); RETURNFUNC(retval);
} }