hamradio/Hamlib
1
0
Fork 0
mirror of https://github.com/Hamlib/Hamlib.git synced 2024-09-21 02:17:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

More state pointer changes

Browse Source 
Done with search/replace
Less than 2300 left to do
This commit is contained in:
George Baltz N3GB 2024-05-31 09:48:30 -04:00
parent ce25f63843
commit 2794d2dfe1
3 changed files with 190 additions and 185 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

247
tests/dumpstate.c
View File

@ -70,6 +70,7 @@ static int print_ext(RIG *rig, const struct confparams *cfp, rig_ptr_t ptr)
int dumpstate(RIG *rig, FILE *fout)
{
const struct rig_caps *caps;
struct rig_state *rs = STATE(rig);
int status, i;
int can_esplit, can_echannel;
char freqbuf[20];
@ -89,20 +90,20 @@ int dumpstate(RIG *rig, FILE *fout)
caps = rig->caps;
fprintf(fout, "Caps dump for model: %u\n", rig->state.rig_model);
fprintf(fout, "Model name:\t%s\n", rig->state.model_name);
fprintf(fout, "Mfg name:\t%s\n", rig->state.mfg_name);
fprintf(fout, "Caps dump for model: %u\n", rs->rig_model);
fprintf(fout, "Model name:\t%s\n", rs->model_name);
fprintf(fout, "Mfg name:\t%s\n", rs->mfg_name);
fprintf(fout, "Hamlib version:\t%s\n", hamlib_version2);
fprintf(fout, "Backend version:\t%s\n", rig->state.version);
fprintf(fout, "Backend copyright:\t%s\n", rig->state.copyright);
fprintf(fout, "Backend status:\t%s\n", rig_strstatus(rig->state.status));
fprintf(fout, "Backend version:\t%s\n", rs->version);
fprintf(fout, "Backend copyright:\t%s\n", rs->copyright);
fprintf(fout, "Backend status:\t%s\n", rig_strstatus(rs->status));
fprintf(fout, "Rig type:\t");
char *unknown = "Unknown";
for (i = 0; rig_type[i].type != -1; ++i)
{
if ((rig_type[i].type & rig->state.rig_type) == rig_type[i].type)
if ((rig_type[i].type & rs->rig_type) == rig_type[i].type)
{
fprintf(fout, "%s ", rig_type[i].description);
unknown = "";
@ -119,7 +120,7 @@ int dumpstate(RIG *rig, FILE *fout)
fprintf(fout, "PTT type:\t");
switch (rig->state.ptt_type)
switch (rs->ptt_type)
{
case RIG_PTT_RIG:
fprintf(fout, "Rig capable\n");
@ -153,7 +154,7 @@ int dumpstate(RIG *rig, FILE *fout)
fprintf(fout, "DCD type:\t");
switch (rig->state.dcd_type)
switch (rs->dcd_type)
{
case RIG_DCD_RIG:
fprintf(fout, "Rig capable\n");
@ -187,22 +188,22 @@ int dumpstate(RIG *rig, FILE *fout)
fprintf(fout, "Port type:\t");
switch (rig->state.port_type)
switch (rs->port_type)
{
case RIG_PORT_SERIAL:
fprintf(fout, "RS-232\n");
fprintf(fout,
"Serial speed: %d..%d baud, %d%c%d, ctrl=%s\n",
rig->state.serial_rate_min,
rig->state.serial_rate_max,
rig->state.serial_data_bits,
rig->state.serial_parity == RIG_PARITY_NONE ? 'N' :
rig->state.serial_parity == RIG_PARITY_ODD ? 'O' :
rig->state.serial_parity == RIG_PARITY_EVEN ? 'E' :
rig->state.serial_parity == RIG_PARITY_MARK ? 'M' : 'S',
rig->state.serial_stop_bits,
rig->state.serial_handshake == RIG_HANDSHAKE_NONE ? "NONE" :
(rig->state.serial_handshake == RIG_HANDSHAKE_XONXOFF ? "XONXOFF" : "CTS/RTS")
rs->serial_rate_min,
rs->serial_rate_max,
rs->serial_data_bits,
rs->serial_parity == RIG_PARITY_NONE ? 'N' :
rs->serial_parity == RIG_PARITY_ODD ? 'O' :
rs->serial_parity == RIG_PARITY_EVEN ? 'E' :
rs->serial_parity == RIG_PARITY_MARK ? 'M' : 'S',
rs->serial_stop_bits,
rs->serial_handshake == RIG_HANDSHAKE_NONE ? "NONE" :
(rs->serial_handshake == RIG_HANDSHAKE_XONXOFF ? "XONXOFF" : "CTS/RTS")
);
break;
@ -238,40 +239,40 @@ int dumpstate(RIG *rig, FILE *fout)
fprintf(fout,
"Write delay: %dms, timeout %dms, %d retry\n",
rig->state.write_delay, rig->state.timeout, rig->state.retry);
rs->write_delay, rs->timeout, rs->retry);
fprintf(fout,
"Post write delay: %dms\n",
rig->state.post_write_delay);
rs->post_write_delay);
fprintf(fout,
"Has targetable VFO: %s\n",
rig->state.targetable_vfo ? "Y" : "N");
rs->targetable_vfo ? "Y" : "N");
fprintf(fout,
"Has async data support: %s\n",
rig->state.async_data_supported ? "Y" : "N");
rs->async_data_supported ? "Y" : "N");
fprintf(fout, "Announce: 0x%x\n", rig->state.announces);
fprintf(fout, "Announce: 0x%x\n", rs->announces);
fprintf(fout,
"Max RIT: -%ld.%ldkHz/+%ld.%ldkHz\n",
rig->state.max_rit / 1000, rig->state.max_rit % 1000,
rig->state.max_rit / 1000, rig->state.max_rit % 1000);
rs->max_rit / 1000, rs->max_rit % 1000,
rs->max_rit / 1000, rs->max_rit % 1000);
fprintf(fout,
"Max XIT: -%ld.%ldkHz/+%ld.%ldkHz\n",
rig->state.max_xit / 1000, rig->state.max_xit % 1000,
rig->state.max_xit / 1000, rig->state.max_xit % 1000);
rs->max_xit / 1000, rs->max_xit % 1000,
rs->max_xit / 1000, rs->max_xit % 1000);
fprintf(fout,
"Max IF-SHIFT: -%ld.%ldkHz/+%ld.%ldkHz\n",
rig->state.max_ifshift / 1000, rig->state.max_ifshift % 1000,
rig->state.max_ifshift / 1000, rig->state.max_ifshift % 1000);
rs->max_ifshift / 1000, rs->max_ifshift % 1000,
rs->max_ifshift / 1000, rs->max_ifshift % 1000);
fprintf(fout, "Preamp:");
for (i = 0; i < HAMLIB_MAXDBLSTSIZ && rig->state.preamp[i] != 0; i++)
for (i = 0; i < HAMLIB_MAXDBLSTSIZ && rs->preamp[i] != 0; i++)
{
fprintf(fout, " %ddB", rig->state.preamp[i]);
fprintf(fout, " %ddB", rs->preamp[i]);
}
if (i == 0)
@ -282,9 +283,9 @@ int dumpstate(RIG *rig, FILE *fout)
fprintf(fout, "\n");
fprintf(fout, "Attenuator:");
for (i = 0; i < HAMLIB_MAXDBLSTSIZ && rig->state.attenuator[i] != 0; i++)
for (i = 0; i < HAMLIB_MAXDBLSTSIZ && rs->attenuator[i] != 0; i++)
{
fprintf(fout, " %ddB", rig->state.attenuator[i]);
fprintf(fout, " %ddB", rs->attenuator[i]);
}
if (i == 0)
@ -297,9 +298,9 @@ int dumpstate(RIG *rig, FILE *fout)
fprintf(fout, "AGC levels:");
const struct icom_priv_caps *priv_caps =
(const struct icom_priv_caps *) rig->state.priv;
(const struct icom_priv_caps *) rs->priv;
if (priv_caps && RIG_BACKEND_NUM(rig->state.rig_model) == RIG_ICOM
if (priv_caps && RIG_BACKEND_NUM(rs->rig_model) == RIG_ICOM
&& priv_caps->agc_levels_present)
{
for (i = 0; i < HAMLIB_MAX_AGC_LEVELS
@ -311,10 +312,10 @@ int dumpstate(RIG *rig, FILE *fout)
}
else
{
for (i = 0; i < HAMLIB_MAX_AGC_LEVELS && i < rig->state.agc_level_count; i++)
for (i = 0; i < HAMLIB_MAX_AGC_LEVELS && i < rs->agc_level_count; i++)
{
fprintf(fout, " %d=%s", rig->state.agc_levels[i],
rig_stragclevel(rig->state.agc_levels[i]));
fprintf(fout, " %d=%s", rs->agc_levels[i],
rig_stragclevel(rs->agc_levels[i]));
}
}
@ -327,12 +328,12 @@ int dumpstate(RIG *rig, FILE *fout)
fprintf(fout, "CTCSS:");
for (i = 0; rig->state.ctcss_list && i < 60
&& rig->state.ctcss_list[i] != 0; i++)
for (i = 0; rs->ctcss_list && i < 60
&& rs->ctcss_list[i] != 0; i++)
{
fprintf(fout,
" %u.%1u",
rig->state.ctcss_list[i] / 10, rig->state.ctcss_list[i] % 10);
rs->ctcss_list[i] / 10, rs->ctcss_list[i] % 10);
}
if (i == 0)
@ -348,9 +349,9 @@ int dumpstate(RIG *rig, FILE *fout)
fprintf(fout, "DCS:");
for (i = 0; rig->state.dcs_list && i < 128 && rig->state.dcs_list[i] != 0; i++)
for (i = 0; rs->dcs_list && i < 128 && rs->dcs_list[i] != 0; i++)
{
fprintf(fout, " %u", rig->state.dcs_list[i]);
fprintf(fout, " %u", rs->dcs_list[i]);
}
if (i == 0)
@ -364,22 +365,22 @@ int dumpstate(RIG *rig, FILE *fout)
fprintf(fout, "\n");
rig_sprintf_func(prntbuf, sizeof(prntbuf), rig->state.has_get_func);
rig_sprintf_func(prntbuf, sizeof(prntbuf), rs->has_get_func);
fprintf(fout, "Get functions: %s\n", prntbuf);
rig_sprintf_func(prntbuf, sizeof(prntbuf), rig->state.has_set_func);
rig_sprintf_func(prntbuf, sizeof(prntbuf), rs->has_set_func);
fprintf(fout, "Set functions: %s\n", prntbuf);
fprintf(fout, "Extra functions:\n");
rig_ext_func_foreach(rig, print_ext, fout);
rig_sprintf_level_gran(prntbuf, sizeof(prntbuf), rig->state.has_get_level,
rig->state.level_gran);
rig_sprintf_level_gran(prntbuf, sizeof(prntbuf), rs->has_get_level,
rs->level_gran);
fprintf(fout, "Get level: %s\n", prntbuf);
if ((rig->state.has_get_level & RIG_LEVEL_RAWSTR)
&& rig->state.str_cal.size == 0
&& !(rig->state.has_get_level & RIG_LEVEL_STRENGTH))
if ((rs->has_get_level & RIG_LEVEL_RAWSTR)
&& rs->str_cal.size == 0
&& !(rs->has_get_level & RIG_LEVEL_STRENGTH))
{
fprintf(fout,
@ -388,14 +389,14 @@ int dumpstate(RIG *rig, FILE *fout)
backend_warnings++;
}
rig_sprintf_level_gran(prntbuf, sizeof(prntbuf), rig->state.has_set_level,
rig->state.level_gran);
rig_sprintf_level_gran(prntbuf, sizeof(prntbuf), rs->has_set_level,
rs->level_gran);
fprintf(fout, "Set level: %s\n", prntbuf);
if (rig->state.has_set_level & RIG_LEVEL_READONLY_LIST)
if (rs->has_set_level & RIG_LEVEL_READONLY_LIST)
{
//fprintf(fout, "Warning--backend can set readonly levels=0x%0llx\n", rig->state.has_set_level & RIG_LEVEL_READONLY_LIST);
//fprintf(fout, "Warning--backend can set readonly levels=0x%0llx\n", rs->has_set_level & RIG_LEVEL_READONLY_LIST);
fprintf(fout, "Warning--backend can set readonly levels\n");
strcat(warnbuf, " READONLY_LEVEL");
backend_warnings++;
@ -404,15 +405,15 @@ int dumpstate(RIG *rig, FILE *fout)
fprintf(fout, "Extra levels:\n");
rig_ext_level_foreach(rig, print_ext, fout);
rig_sprintf_parm_gran(prntbuf, sizeof(prntbuf), rig->state.has_get_parm,
rig->state.parm_gran);
rig_sprintf_parm_gran(prntbuf, sizeof(prntbuf), rs->has_get_parm,
rs->parm_gran);
fprintf(fout, "Get parameters: %s\n", prntbuf);
rig_sprintf_parm_gran(prntbuf, sizeof(prntbuf), rig->state.has_set_parm,
rig->state.parm_gran);
rig_sprintf_parm_gran(prntbuf, sizeof(prntbuf), rs->has_set_parm,
rs->parm_gran);
fprintf(fout, "Set parameters: %s\n", prntbuf);
if (rig->state.has_set_parm & RIG_PARM_READONLY_LIST)
if (rs->has_set_parm & RIG_PARM_READONLY_LIST)
{
fprintf(fout, "Warning--backend can set readonly parms!\n");
strcat(warnbuf, " READONLY_PARM");
@ -423,9 +424,9 @@ int dumpstate(RIG *rig, FILE *fout)
rig_ext_parm_foreach(rig, print_ext, fout);
if (rig->state.mode_list != 0)
if (rs->mode_list != 0)
{
rig_sprintf_mode(prntbuf, sizeof(prntbuf), rig->state.mode_list);
rig_sprintf_mode(prntbuf, sizeof(prntbuf), rs->mode_list);
}
else
{
@ -436,9 +437,9 @@ int dumpstate(RIG *rig, FILE *fout)
fprintf(fout, "Mode list: %s\n", prntbuf);
if (rig->state.vfo_list != 0)
if (rs->vfo_list != 0)
{
rig_sprintf_vfo(prntbuf, sizeof(prntbuf), rig->state.vfo_list);
rig_sprintf_vfo(prntbuf, sizeof(prntbuf), rs->vfo_list);
}
else
{
@ -449,26 +450,26 @@ int dumpstate(RIG *rig, FILE *fout)
fprintf(fout, "VFO list: %s\n", prntbuf);
rig_sprintf_vfop(prntbuf, sizeof(prntbuf), rig->state.vfo_ops);
rig_sprintf_vfop(prntbuf, sizeof(prntbuf), rs->vfo_ops);
fprintf(fout, "VFO Ops: %s\n", prntbuf);
rig_sprintf_scan(prntbuf, sizeof(prntbuf), rig->state.scan_ops);
rig_sprintf_scan(prntbuf, sizeof(prntbuf), rs->scan_ops);
fprintf(fout, "Scan Ops: %s\n", prntbuf);
fprintf(fout, "Number of banks:\t%d\n", rig->state.bank_qty);
fprintf(fout, "Memory name desc size:\t%d\n", rig->state.chan_desc_sz);
fprintf(fout, "Number of banks:\t%d\n", rs->bank_qty);
fprintf(fout, "Memory name desc size:\t%d\n", rs->chan_desc_sz);
fprintf(fout, "Memories:");
for (i = 0; i < HAMLIB_CHANLSTSIZ && rig->state.chan_list[i].type; i++)
for (i = 0; i < HAMLIB_CHANLSTSIZ && rs->chan_list[i].type; i++)
{
fprintf(fout,
"\n\t%d..%d: \t%s",
rig->state.chan_list[i].startc,
rig->state.chan_list[i].endc,
rig_strmtype(rig->state.chan_list[i].type));
rs->chan_list[i].startc,
rs->chan_list[i].endc,
rig_strmtype(rs->chan_list[i].type));
fprintf(fout, "\n\t Mem caps: ");
dump_chan_caps(&rig->state.chan_list[i].mem_caps, fout);
dump_chan_caps(&rs->chan_list[i].mem_caps, fout);
}
if (i == 0)
@ -478,57 +479,57 @@ int dumpstate(RIG *rig, FILE *fout)
fprintf(fout, "\n");
label1 = rig->state.tx_range_list1->label;
label1 = rs->tx_range_list1->label;
label1 = label1 == NULL ? "TBD" : label1;
fprintf(fout, "TX ranges #1 for %s:\n", label1);
range_print(fout, rig->state.tx_range_list1, 0);
range_print(fout, rs->tx_range_list1, 0);
labelrx1 = rig->state.rx_range_list1->label;
labelrx1 = rs->rx_range_list1->label;
labelrx1 = labelrx1 == NULL ? "TBD" : labelrx1;
fprintf(fout, "RX ranges #1 for %s:\n", labelrx1);
range_print(fout, rig->state.rx_range_list1, 1);
range_print(fout, rs->rx_range_list1, 1);
label2 = rig->state.rx_range_list2->label;
label2 = rs->rx_range_list2->label;
label2 = label2 == NULL ? "TBD" : label2;
fprintf(fout, "TX ranges #2 for %s:\n", label2);
range_print(fout, rig->state.tx_range_list2, 0);
range_print(fout, rs->tx_range_list2, 0);
label2 = rig->state.rx_range_list2->label;
label2 = rs->rx_range_list2->label;
label2 = label2 == NULL ? "TBD" : label2;
fprintf(fout, "RX ranges #2 for %s:\n", label2);
range_print(fout, rig->state.rx_range_list2, 1);
range_print(fout, rs->rx_range_list2, 1);
label3 = rig->state.rx_range_list3->label;
label3 = rs->rx_range_list3->label;
label3 = label3 == NULL ? "TBD" : label3;
fprintf(fout, "TX ranges #3 for %s:\n", label3);
range_print(fout, rig->state.tx_range_list3, 0);
range_print(fout, rs->tx_range_list3, 0);
label3 = rig->state.rx_range_list3->label;
label3 = rs->rx_range_list3->label;
label3 = label3 == NULL ? "TBD" : label3;
fprintf(fout, "RX ranges #3 for %s:\n", label3);
range_print(fout, rig->state.rx_range_list3, 1);
range_print(fout, rs->rx_range_list3, 1);
label4 = rig->state.rx_range_list4->label;
label4 = rs->rx_range_list4->label;
label4 = label4 == NULL ? "TBD" : label4;
fprintf(fout, "TX ranges #4 for %s:\n", label4);
range_print(fout, rig->state.tx_range_list5, 0);
range_print(fout, rs->tx_range_list5, 0);
label4 = rig->state.rx_range_list4->label;
label4 = rs->rx_range_list4->label;
label4 = label4 == NULL ? "TBD" : label4;
fprintf(fout, "RX ranges #4 for %s:\n", label4);
range_print(fout, rig->state.rx_range_list5, 1);
range_print(fout, rs->rx_range_list5, 1);
label5 = rig->state.rx_range_list5->label;
label5 = rs->rx_range_list5->label;
label5 = label5 == NULL ? "TBD" : label5;
fprintf(fout, "TX ranges #5 for %s:\n", label5);
range_print(fout, rig->state.tx_range_list5, 0);
range_print(fout, rs->tx_range_list5, 0);
label5 = rig->state.rx_range_list5->label;
label5 = rs->rx_range_list5->label;
label5 = label5 == NULL ? "TBD" : label5;
fprintf(fout, "RX ranges #5 for %s:\n", label5);
range_print(fout, rig->state.rx_range_list5, 1);
range_print(fout, rs->rx_range_list5, 1);
status = range_sanity_check(rig->state.tx_range_list1, 0);
status = range_sanity_check(rs->tx_range_list1, 0);
fprintf(fout,
"TX ranges #1 status for %s:\t%s (%d)\n", label1,
status ? "Bad" : "OK",
@ -540,7 +541,7 @@ int dumpstate(RIG *rig, FILE *fout)
backend_warnings++;
}
status = range_sanity_check(rig->state.rx_range_list1, 1);
status = range_sanity_check(rs->rx_range_list1, 1);
fprintf(fout,
"RX ranges #1 status for %s:\t%s (%d)\n", labelrx1,
status ? "Bad" : "OK",
@ -552,7 +553,7 @@ int dumpstate(RIG *rig, FILE *fout)
backend_warnings++;
}
status = range_sanity_check(rig->state.tx_range_list2, 0);
status = range_sanity_check(rs->tx_range_list2, 0);
fprintf(fout,
"TX ranges #2 status for %s:\t%s (%d)\n", label2,
status ? "Bad" : "OK",
@ -564,7 +565,7 @@ int dumpstate(RIG *rig, FILE *fout)
backend_warnings++;
}
status = range_sanity_check(rig->state.rx_range_list2, 1);
status = range_sanity_check(rs->rx_range_list2, 1);
fprintf(fout,
"RX ranges #2 status for %s:\t%s (%d)\n", label2,
status ? "Bad" : "OK",
@ -576,7 +577,7 @@ int dumpstate(RIG *rig, FILE *fout)
backend_warnings++;
}
status = range_sanity_check(rig->state.tx_range_list3, 0);
status = range_sanity_check(rs->tx_range_list3, 0);
fprintf(fout,
"TX ranges #3 status for %s:\t%s (%d)\n", label3,
status ? "Bad" : "OK",
@ -588,7 +589,7 @@ int dumpstate(RIG *rig, FILE *fout)
backend_warnings++;
}
status = range_sanity_check(rig->state.rx_range_list3, 1);
status = range_sanity_check(rs->rx_range_list3, 1);
fprintf(fout,
"RX ranges #3 status for %s:\t%s (%d)\n", label3,
status ? "Bad" : "OK",
@ -600,7 +601,7 @@ int dumpstate(RIG *rig, FILE *fout)
backend_warnings++;
}
status = range_sanity_check(rig->state.tx_range_list4, 0);
status = range_sanity_check(rs->tx_range_list4, 0);
fprintf(fout,
"TX ranges #4 status for %s:\t%s (%d)\n", label4,
status ? "Bad" : "OK",
@ -612,7 +613,7 @@ int dumpstate(RIG *rig, FILE *fout)
backend_warnings++;
}
status = range_sanity_check(rig->state.rx_range_list4, 1);
status = range_sanity_check(rs->rx_range_list4, 1);
fprintf(fout,
"RX ranges #4 status for %s:\t%s (%d)\n", label4,
status ? "Bad" : "OK",
@ -624,7 +625,7 @@ int dumpstate(RIG *rig, FILE *fout)
backend_warnings++;
}
status = range_sanity_check(rig->state.tx_range_list5, 0);
status = range_sanity_check(rs->tx_range_list5, 0);
fprintf(fout,
"TX ranges #5 status for %s:\t%s (%d)\n", label5,
status ? "Bad" : "OK",
@ -636,7 +637,7 @@ int dumpstate(RIG *rig, FILE *fout)
backend_warnings++;
}
status = range_sanity_check(rig->state.rx_range_list5, 1);
status = range_sanity_check(rs->rx_range_list5, 1);
fprintf(fout,
"RX ranges #5 status for %s:\t%s (%d)\n", label5,
status ? "Bad" : "OK",
@ -651,18 +652,18 @@ int dumpstate(RIG *rig, FILE *fout)
fprintf(fout, "Tuning steps:");
for (i = 0; i < HAMLIB_TSLSTSIZ
&& !RIG_IS_TS_END(rig->state.tuning_steps[i]); i++)
&& !RIG_IS_TS_END(rs->tuning_steps[i]); i++)
{
if (rig->state.tuning_steps[i].ts == RIG_TS_ANY)
if (rs->tuning_steps[i].ts == RIG_TS_ANY)
{
strcpy(freqbuf, "ANY"); /* strcpy! Looks safe for now */
}
else
{
sprintf_freq(freqbuf, sizeof(freqbuf), rig->state.tuning_steps[i].ts);
sprintf_freq(freqbuf, sizeof(freqbuf), rs->tuning_steps[i].ts);
}
rig_sprintf_mode(prntbuf, sizeof(prntbuf), rig->state.tuning_steps[i].modes);
rig_sprintf_mode(prntbuf, sizeof(prntbuf), rs->tuning_steps[i].modes);
fprintf(fout, "\n\t%s: \t%s", freqbuf, prntbuf);
}
@ -674,7 +675,7 @@ int dumpstate(RIG *rig, FILE *fout)
}
fprintf(fout, "\n");
status = ts_sanity_check(rig->state.tuning_steps);
status = ts_sanity_check(rs->tuning_steps);
fprintf(fout, "Tuning steps status:\t%s (%d)\n", status ? "Bad" : "OK", status);
if (status)
@ -685,18 +686,18 @@ int dumpstate(RIG *rig, FILE *fout)
fprintf(fout, "Filters:");
for (i = 0; i < HAMLIB_FLTLSTSIZ && !RIG_IS_FLT_END(rig->state.filters[i]); i++)
for (i = 0; i < HAMLIB_FLTLSTSIZ && !RIG_IS_FLT_END(rs->filters[i]); i++)
{
if (rig->state.filters[i].width == RIG_FLT_ANY)
if (rs->filters[i].width == RIG_FLT_ANY)
{
strcpy(freqbuf, "ANY");
}
else
{
sprintf_freq(freqbuf, sizeof(freqbuf), rig->state.filters[i].width);
sprintf_freq(freqbuf, sizeof(freqbuf), rs->filters[i].width);
}
rig_sprintf_mode(prntbuf, sizeof(prntbuf), rig->state.filters[i].modes);
rig_sprintf_mode(prntbuf, sizeof(prntbuf), rs->filters[i].modes);
fprintf(fout, "\n\t%s: \t%s", freqbuf, prntbuf);
}
@ -735,10 +736,10 @@ int dumpstate(RIG *rig, FILE *fout)
fprintf(fout, "Spectrum scopes:");
for (i = 0; i < HAMLIB_MAX_SPECTRUM_SCOPES
&& rig->state.spectrum_scopes[i].name != NULL; i++)
&& rs->spectrum_scopes[i].name != NULL; i++)
{
fprintf(fout, " %d=\"%s\"", rig->state.spectrum_scopes[i].id,
rig->state.spectrum_scopes[i].name);
fprintf(fout, " %d=\"%s\"", rs->spectrum_scopes[i].id,
rs->spectrum_scopes[i].name);
}
if (i == 0)
@ -748,22 +749,22 @@ int dumpstate(RIG *rig, FILE *fout)
fprintf(fout, "\n");
rig_sprintf_spectrum_modes(prntbuf, sizeof(prntbuf), rig->state.spectrum_modes);
rig_sprintf_spectrum_modes(prntbuf, sizeof(prntbuf), rs->spectrum_modes);
fprintf(fout, "Spectrum modes: %s\n", prntbuf);
rig_sprintf_spectrum_spans(prntbuf, sizeof(prntbuf), rig->state.spectrum_spans);
rig_sprintf_spectrum_spans(prntbuf, sizeof(prntbuf), rs->spectrum_spans);
fprintf(fout, "Spectrum spans: %s\n", prntbuf);
rig_sprintf_spectrum_avg_modes(prntbuf, sizeof(prntbuf),
rig->state.spectrum_avg_modes);
rs->spectrum_avg_modes);
fprintf(fout, "Spectrum averaging modes: %s\n", prntbuf);
fprintf(fout, "Spectrum attenuator:");
for (i = 0; i < HAMLIB_MAXDBLSTSIZ
&& rig->state.spectrum_attenuator[i] != 0; i++)
&& rs->spectrum_attenuator[i] != 0; i++)
{
fprintf(fout, " %ddB", rig->state.spectrum_attenuator[i]);
fprintf(fout, " %ddB", rs->spectrum_attenuator[i]);
}
if (i == 0)
@ -773,7 +774,7 @@ int dumpstate(RIG *rig, FILE *fout)
fprintf(fout, "\n");
fprintf(fout, "Has priv data:\t%c\n", rig->state.priv != NULL ? 'Y' : 'N');
fprintf(fout, "Has priv data:\t%c\n", rs->priv != NULL ? 'Y' : 'N');
/*
* Status is either 'Y'es, 'E'mulated, 'N'o
*
@ -920,7 +921,7 @@ int dumpstate(RIG *rig, FILE *fout)
can_echannel = rig->caps->set_mem
&& ((rig->caps->set_vfo
&& ((rig->state.vfo_list & RIG_VFO_MEM) == RIG_VFO_MEM))
&& ((rs->vfo_list & RIG_VFO_MEM) == RIG_VFO_MEM))
|| (rig->caps->vfo_op
&& rig_has_vfo_op(rig, RIG_OP_TO_VFO | RIG_OP_FROM_VFO)));

51
tests/memload.c
View File

@ -120,6 +120,7 @@ int set_chan(RIG *rig, channel_t *chan, xmlNodePtr node)
{
xmlChar *prop;
int i, n;
struct rig_state *rs = STATE(rig);
memset(chan, 0, sizeof(channel_t));
chan->vfo = RIG_VFO_MEM;
@ -138,8 +139,8 @@ int set_chan(RIG *rig, channel_t *chan, xmlNodePtr node)
/* find channel caps */
for (i = 0; i < HAMLIB_CHANLSTSIZ ; i++)
{
if (rig->state.chan_list[i].startc <= n
&& rig->state.chan_list[i].endc >= n)
if (rs->chan_list[i].startc <= n
&& rs->chan_list[i].endc >= n)
{
break;
@ -150,7 +151,7 @@ int set_chan(RIG *rig, channel_t *chan, xmlNodePtr node)
fprintf(stderr, "node %d %d\n", n, i);
if (rig->state.chan_list[i].mem_caps.bank_num)
if (rs->chan_list[i].mem_caps.bank_num)
{
prop = xmlGetProp(node, (unsigned char *) "bank_num");
@ -160,7 +161,7 @@ int set_chan(RIG *rig, channel_t *chan, xmlNodePtr node)
}
}
if (rig->state.chan_list[i].mem_caps.channel_desc)
if (rs->chan_list[i].mem_caps.channel_desc)
{
prop = xmlGetProp(node, (unsigned char *) "channel_desc");
@ -170,7 +171,7 @@ int set_chan(RIG *rig, channel_t *chan, xmlNodePtr node)
}
}
if (rig->state.chan_list[i].mem_caps.ant)
if (rs->chan_list[i].mem_caps.ant)
{
prop = xmlGetProp(node, (unsigned char *) "ant");
@ -180,7 +181,7 @@ int set_chan(RIG *rig, channel_t *chan, xmlNodePtr node)
}
}
if (rig->state.chan_list[i].mem_caps.freq)
if (rs->chan_list[i].mem_caps.freq)
{
prop = xmlGetProp(node, (unsigned char *) "freq");
@ -190,7 +191,7 @@ int set_chan(RIG *rig, channel_t *chan, xmlNodePtr node)
}
}
if (rig->state.chan_list[i].mem_caps.mode)
if (rs->chan_list[i].mem_caps.mode)
{
prop = xmlGetProp(node, (unsigned char *) "mode");
@ -200,7 +201,7 @@ int set_chan(RIG *rig, channel_t *chan, xmlNodePtr node)
}
}
if (rig->state.chan_list[i].mem_caps.width)
if (rs->chan_list[i].mem_caps.width)
{
prop = xmlGetProp(node, (unsigned char *) "width");
@ -210,7 +211,7 @@ int set_chan(RIG *rig, channel_t *chan, xmlNodePtr node)
}
}
if (rig->state.chan_list[i].mem_caps.tx_freq)
if (rs->chan_list[i].mem_caps.tx_freq)
{
prop = xmlGetProp(node, (unsigned char *) "tx_freq");
@ -220,7 +221,7 @@ int set_chan(RIG *rig, channel_t *chan, xmlNodePtr node)
}
}
if (rig->state.chan_list[i].mem_caps.tx_mode)
if (rs->chan_list[i].mem_caps.tx_mode)
{
prop = xmlGetProp(node, (unsigned char *)"tx_mode");
@ -230,7 +231,7 @@ int set_chan(RIG *rig, channel_t *chan, xmlNodePtr node)
}
}
if (rig->state.chan_list[i].mem_caps.tx_width)
if (rs->chan_list[i].mem_caps.tx_width)
{
prop = xmlGetProp(node, (unsigned char *)"tx_width");
@ -240,7 +241,7 @@ int set_chan(RIG *rig, channel_t *chan, xmlNodePtr node)
}
}
if (rig->state.chan_list[i].mem_caps.split)
if (rs->chan_list[i].mem_caps.split)
{
chan->split = RIG_SPLIT_OFF;
prop = xmlGetProp(node, (unsigned char *)"split");
@ -251,7 +252,7 @@ int set_chan(RIG *rig, channel_t *chan, xmlNodePtr node)
{
chan->split = RIG_SPLIT_ON;
if (rig->state.chan_list[i].mem_caps.tx_vfo)
if (rs->chan_list[i].mem_caps.tx_vfo)
{
prop = xmlGetProp(node, (unsigned char *)"tx_vfo");
@ -264,7 +265,7 @@ int set_chan(RIG *rig, channel_t *chan, xmlNodePtr node)
}
}
if (rig->state.chan_list[i].mem_caps.rptr_shift)
if (rs->chan_list[i].mem_caps.rptr_shift)
{
prop = xmlGetProp(node, (unsigned char *)"rptr_shift");
@ -286,7 +287,7 @@ int set_chan(RIG *rig, channel_t *chan, xmlNodePtr node)
}
}
if (rig->state.chan_list[i].mem_caps.rptr_offs
if (rs->chan_list[i].mem_caps.rptr_offs
&& chan->rptr_shift != RIG_RPT_SHIFT_NONE)
{
prop = xmlGetProp(node, (unsigned char *)"rptr_offs");
@ -298,7 +299,7 @@ int set_chan(RIG *rig, channel_t *chan, xmlNodePtr node)
}
}
if (rig->state.chan_list[i].mem_caps.tuning_step)
if (rs->chan_list[i].mem_caps.tuning_step)
{
prop = xmlGetProp(node, (unsigned char *)"tuning_step");
@ -308,7 +309,7 @@ int set_chan(RIG *rig, channel_t *chan, xmlNodePtr node)
}
}
if (rig->state.chan_list[i].mem_caps.rit)
if (rs->chan_list[i].mem_caps.rit)
{
prop = xmlGetProp(node, (unsigned char *)"rit");
@ -318,7 +319,7 @@ int set_chan(RIG *rig, channel_t *chan, xmlNodePtr node)
}
}
if (rig->state.chan_list[i].mem_caps.xit)
if (rs->chan_list[i].mem_caps.xit)
{
prop = xmlGetProp(node, (unsigned char *)"xit");
@ -328,7 +329,7 @@ int set_chan(RIG *rig, channel_t *chan, xmlNodePtr node)
}
}
if (rig->state.chan_list[i].mem_caps.funcs)
if (rs->chan_list[i].mem_caps.funcs)
{
prop = xmlGetProp(node, (unsigned char *)"funcs");
@ -338,7 +339,7 @@ int set_chan(RIG *rig, channel_t *chan, xmlNodePtr node)
}
}
if (rig->state.chan_list[i].mem_caps.ctcss_tone)
if (rs->chan_list[i].mem_caps.ctcss_tone)
{
prop = xmlGetProp(node, (unsigned char *)"ctcss_tone");
@ -348,7 +349,7 @@ int set_chan(RIG *rig, channel_t *chan, xmlNodePtr node)
}
}
if (rig->state.chan_list[i].mem_caps.ctcss_sql)
if (rs->chan_list[i].mem_caps.ctcss_sql)
{
prop = xmlGetProp(node, (unsigned char *)"ctcss_sql");
@ -358,7 +359,7 @@ int set_chan(RIG *rig, channel_t *chan, xmlNodePtr node)
}
}
if (rig->state.chan_list[i].mem_caps.dcs_code)
if (rs->chan_list[i].mem_caps.dcs_code)
{
prop = xmlGetProp(node, (unsigned char *)"dcs_code");
@ -368,7 +369,7 @@ int set_chan(RIG *rig, channel_t *chan, xmlNodePtr node)
}
}
if (rig->state.chan_list[i].mem_caps.dcs_sql)
if (rs->chan_list[i].mem_caps.dcs_sql)
{
prop = xmlGetProp(node, (unsigned char *)"dcs_sql");
@ -378,7 +379,7 @@ int set_chan(RIG *rig, channel_t *chan, xmlNodePtr node)
}
}
if (rig->state.chan_list[i].mem_caps.scan_group)
if (rs->chan_list[i].mem_caps.scan_group)
{
prop = xmlGetProp(node, (unsigned char *)"scan_group");
@ -388,7 +389,7 @@ int set_chan(RIG *rig, channel_t *chan, xmlNodePtr node)
}
}
if (rig->state.chan_list[i].mem_caps.flags)
if (rs->chan_list[i].mem_caps.flags)
{
prop = xmlGetProp(node, (unsigned char *)"flags");

77
tests/rigctl_parse.c
View File

@ -706,6 +706,7 @@ int rigctl_parse(RIG *my_rig, FILE *fin, FILE *fout, char *argv[], int argc,
int retcode = -RIG_EINTERNAL; /* generic return code from functions */
unsigned char cmd;
struct test_table *cmd_entry = NULL;
struct rig_state *rs = STATE(my_rig);
char command[MAXARGSZ + 1];
char arg1[MAXARGSZ + 1], *p1 = NULL;
@ -868,7 +869,7 @@ int rigctl_parse(RIG *my_rig, FILE *fin, FILE *fout, char *argv[], int argc,
return (RIG_OK);
}
my_rig->state.vfo_opt = *vfo_opt;
rs->vfo_opt = *vfo_opt;
if (cmd == 'Q' || cmd == 'q')
{
@ -1779,10 +1780,10 @@ readline_repeat:
rig_debug(RIG_DEBUG_TRACE, "%s: vfo_opt=%d\n", __func__, *vfo_opt);
if (my_rig->state.comm_state == 0)
if (rs->comm_state == 0)
{
rig_debug(RIG_DEBUG_WARN, "%s: %p rig not open...trying to reopen\n", __func__,
&my_rig->state.comm_state);
&rs->comm_state);
rig_open(my_rig);
}
@ -1808,7 +1809,7 @@ readline_repeat:
else
{
// Allow only certain commands when the rig is powered off
if (my_rig->state.powerstat == RIG_POWER_OFF && (rig_powerstat == RIG_POWER_OFF
if (rs->powerstat == RIG_POWER_OFF && (rig_powerstat == RIG_POWER_OFF
|| rig_powerstat == RIG_POWER_STANDBY)
&& cmd_entry->cmd != '1' // dump_caps
&& cmd_entry->cmd != '3' // dump_conf
@ -1846,7 +1847,7 @@ readline_repeat:
// we need to copy client_version to our thread in case there are multiple client versions
// client_version is used to determine any backward compatibility requirements or problems
strncpy(client_version, my_rig->state.client_version, sizeof(client_version));
strncpy(client_version, rs->client_version, sizeof(client_version));
}
@ -1927,15 +1928,16 @@ declare_proto_rig(hamlib_version)
declare_proto_rig(client_version)
{
struct rig_state *rs = STATE(rig);
if ((interactive && prompt) || (interactive && !prompt && ext_resp))
{
fprintf(fout, "%s: ", cmd->arg1);
}
fprintf(fout, "%s%c", arg1, resp_sep);
strncpy(rig->state.client_version, arg1, sizeof(rig->state.client_version) - 1);
strncpy(rs->client_version, arg1, sizeof(rs->client_version) - 1);
rig_debug(RIG_DEBUG_VERBOSE, "%s: client_version=%s\n", __func__,
rig->state.client_version);
rs->client_version);
return RIG_OK;
}
@ -2270,15 +2272,16 @@ declare_proto_rig(set_mode)
{
rmode_t mode;
pbwidth_t width;
struct rig_state *rs = STATE(rig);
ENTERFUNC2;
if (rig->state.lock_mode || lock_mode) { RETURNFUNC2(RIG_OK); }
if (rs->lock_mode || lock_mode) { RETURNFUNC2(RIG_OK); }
if (!strcmp(arg1, "?"))
{
char s[SPRINTF_MAX_SIZE];
rig_sprintf_mode(s, sizeof(s), rig->state.mode_list);
rig_sprintf_mode(s, sizeof(s), rs->mode_list);
fprintf(fout, "%s\n", s);
RETURNFUNC2(RIG_OK);
}
@ -2286,7 +2289,7 @@ declare_proto_rig(set_mode)
mode = rig_parse_mode(arg1);
CHKSCN1ARG(sscanf(arg2, "%ld", &width));
if (rig->state.lock_mode) { RETURNFUNC2(RIG_OK); }
if (rs->lock_mode) { RETURNFUNC2(RIG_OK); }
RETURNFUNC2(rig_set_mode(rig, vfo, mode, width));
}
@ -2336,7 +2339,7 @@ declare_proto_rig(set_vfo)
if (!strcmp(arg1, "?"))
{
char s[SPRINTF_MAX_SIZE];
rig_sprintf_vfo(s, sizeof(s), rig->state.vfo_list);
rig_sprintf_vfo(s, sizeof(s), STATE(rig)->vfo_list);
fprintf(fout, "%s\n", s);
RETURNFUNC2(RIG_OK);
}
@ -2426,7 +2429,7 @@ declare_proto_rig(get_vfo_info)
if (!strcmp(arg1, "?"))
{
char s[SPRINTF_MAX_SIZE];
rig_sprintf_vfo(s, sizeof(s), rig->state.vfo_list);
rig_sprintf_vfo(s, sizeof(s), STATE(rig)->vfo_list);
fprintf(fout, "%s\n", s);
RETURNFUNC2(RIG_OK);
}
@ -2474,7 +2477,7 @@ declare_proto_rig(get_vfo_list)
ENTERFUNC2;
rig_sprintf_vfo(prntbuf, sizeof(prntbuf), rig->state.vfo_list);
rig_sprintf_vfo(prntbuf, sizeof(prntbuf), STATE(rig)->vfo_list);
if ((interactive && prompt) || (interactive && !prompt && ext_resp))
{
@ -2511,7 +2514,7 @@ declare_proto_rig(get_modes)
ENTERFUNC2;
rig_strrmodes(rig->state.mode_list, prntbuf, sizeof(prntbuf));
rig_strrmodes(STATE(rig)->mode_list, prntbuf, sizeof(prntbuf));
if ((interactive && prompt) || (interactive && !prompt && ext_resp))
{
@ -2986,7 +2989,7 @@ declare_proto_rig(set_split_mode)
if (!strcmp(arg1, "?"))
{
char s[SPRINTF_MAX_SIZE];
rig_sprintf_mode(s, sizeof(s), rig->state.mode_list);
rig_sprintf_mode(s, sizeof(s), STATE(rig)->mode_list);
fprintf(fout, "%s\n", s);
RETURNFUNC2(RIG_OK);
}
@ -3048,7 +3051,7 @@ declare_proto_rig(set_split_freq_mode)
if (!strcmp(arg1, "?"))
{
char s[SPRINTF_MAX_SIZE];
rig_sprintf_mode(s, sizeof(s), rig->state.mode_list);
rig_sprintf_mode(s, sizeof(s), STATE(rig)->mode_list);
fprintf(fout, "%s\n", s);
RETURNFUNC2(RIG_OK);
}
@ -3116,7 +3119,7 @@ declare_proto_rig(set_split_vfo)
if (!strcmp(arg2, "?"))
{
char s[SPRINTF_MAX_SIZE];
rig_sprintf_vfo(s, sizeof(s), rig->state.vfo_list);
rig_sprintf_vfo(s, sizeof(s), STATE(rig)->vfo_list);
fprintf(fout, "%s\n", s);
RETURNFUNC2(RIG_OK);
}
@ -3293,7 +3296,7 @@ declare_proto_rig(set_level)
if (!strcmp(arg1, "?"))
{
char s[SPRINTF_MAX_SIZE];
rig_sprintf_level(s, sizeof(s), rig->state.has_set_level);
rig_sprintf_level(s, sizeof(s), STATE(rig)->has_set_level);
fputs(s, fout);
if (rig->caps->set_ext_level)
@ -3409,7 +3412,7 @@ declare_proto_rig(get_level)
if (!strcmp(arg1, "?"))
{
char s[SPRINTF_MAX_SIZE];
rig_sprintf_level(s, sizeof(s), rig->state.has_get_level);
rig_sprintf_level(s, sizeof(s), STATE(rig)->has_get_level);
fputs(s, fout);
if (rig->caps->get_ext_level)
@ -3546,7 +3549,7 @@ declare_proto_rig(set_func)
if (!strcmp(arg1, "?"))
{
char s[SPRINTF_MAX_SIZE];
rig_sprintf_func(s, sizeof(s), rig->state.has_set_func);
rig_sprintf_func(s, sizeof(s), STATE(rig)->has_set_func);
fprintf(fout, "%s\n", s);
RETURNFUNC2(RIG_OK);
}
@ -3586,7 +3589,7 @@ declare_proto_rig(get_func)
if (!strcmp(arg1, "?"))
{
char s[SPRINTF_MAX_SIZE];
rig_sprintf_func(s, sizeof(s), rig->state.has_get_func);
rig_sprintf_func(s, sizeof(s), STATE(rig)->has_get_func);
fprintf(fout, "%s\n", s);
RETURNFUNC2(RIG_OK);
}
@ -3650,7 +3653,7 @@ declare_proto_rig(set_parm)
if (!strcmp(arg1, "?"))
{
char s[SPRINTF_MAX_SIZE];
rig_sprintf_parm(s, sizeof(s), rig->state.has_set_parm);
rig_sprintf_parm(s, sizeof(s), STATE(rig)->has_set_parm);
fprintf(fout, "%s\n", s);
RETURNFUNC2(RIG_OK);
}
@ -3778,7 +3781,7 @@ declare_proto_rig(get_parm)
if (!strcmp(arg1, "?"))
{
char s[SPRINTF_MAX_SIZE];
rig_sprintf_parm(s, sizeof(s), rig->state.has_get_parm);
rig_sprintf_parm(s, sizeof(s), STATE(rig)->has_get_parm);
fprintf(fout, "%s\n", s);
RETURNFUNC2(RIG_OK);
}
@ -3964,7 +3967,7 @@ declare_proto_rig(vfo_op)
if (!strcmp(arg1, "?"))
{
char s[SPRINTF_MAX_SIZE];
rig_sprintf_vfop(s, sizeof(s), rig->state.vfo_ops);
rig_sprintf_vfop(s, sizeof(s), STATE(rig)->vfo_ops);
fprintf(fout, "%s\n", s);
RETURNFUNC2(RIG_OK);
}
@ -4589,7 +4592,7 @@ declare_proto_rig(dump_caps)
declare_proto_rig(dump_state)
{
int i;
struct rig_state *rs = &rig->state;
struct rig_state *rs = STATE(rig);
char buf[1024];
ENTERFUNC2;
@ -4761,13 +4764,13 @@ declare_proto_rig(dump_state)
{
if (RIG_LEVEL_IS_FLOAT(i))
{
fprintf(fout, "%d=%g,%g,%g;", i, rig->state.level_gran[i].min.f,
rig->state.level_gran[i].max.f, rig->state.level_gran[i].step.f);
fprintf(fout, "%d=%g,%g,%g;", i, rs->level_gran[i].min.f,
rs->level_gran[i].max.f, rs->level_gran[i].step.f);
}
else
{
fprintf(fout, "%d=%d,%d,%d;", i, rig->state.level_gran[i].min.i,
rig->state.level_gran[i].max.i, rig->state.level_gran[i].step.i);
fprintf(fout, "%d=%d,%d,%d;", i, rs->level_gran[i].min.i,
rs->level_gran[i].max.i, rs->level_gran[i].step.i);
}
}
@ -4777,20 +4780,20 @@ declare_proto_rig(dump_state)
{
if (RIG_LEVEL_IS_FLOAT(i))
{
fprintf(fout, "%d=%g,%g,%g;", i, rig->state.parm_gran[i].min.f,
rig->state.parm_gran[i].max.f, rig->state.parm_gran[i].step.f);
fprintf(fout, "%d=%g,%g,%g;", i, rs->parm_gran[i].min.f,
rs->parm_gran[i].max.f, rs->parm_gran[i].step.f);
}
else
{
fprintf(fout, "%d=%d,%d,%d;", i, rig->state.level_gran[i].min.i,
rig->state.level_gran[i].max.i, rig->state.level_gran[i].step.i);
fprintf(fout, "%d=%d,%d,%d;", i, rs->level_gran[i].min.i,
rs->level_gran[i].max.i, rs->level_gran[i].step.i);
}
}
fprintf(fout, "\n");
rig->state.rig_model = rig->caps->rig_model;
fprintf(fout, "rig_model=%d\n", rig->state.rig_model);
rs->rig_model = rig->caps->rig_model;
fprintf(fout, "rig_model=%d\n", rs->rig_model);
fprintf(fout, "hamlib_version=%s\n", hamlib_version2);
fprintf(fout, "done\n");
}
@ -5400,7 +5403,7 @@ declare_proto_rig(chk_vfo)
fprintf(fout, "%s: ", cmd->arg1); /* i.e. "Frequency" */
}
fprintf(fout, "%d\n", rig->state.vfo_opt);
fprintf(fout, "%d\n", STATE(rig)->vfo_opt);
chk_vfo_executed = 1; // this allows us to control dump_state version
@ -5414,7 +5417,7 @@ declare_proto_rig(set_vfo_opt)
ENTERFUNC2;
CHKSCN1ARG(sscanf(arg1, "%d", &opt));
*vfo_opt = rig->state.vfo_opt = opt;
*vfo_opt = STATE(rig)->vfo_opt = opt;
RETURNFUNC2(rig_set_vfo_opt(rig, opt));
}