From 2794d2dfe143e88452d58f5a3924c1bce52390de Mon Sep 17 00:00:00 2001 From: George Baltz N3GB Date: Fri, 31 May 2024 09:48:30 -0400 Subject: [PATCH] More state pointer changes Done with search/replace Less than 2300 left to do --- tests/dumpstate.c | 247 ++++++++++++++++++++++--------------------- tests/memload.c | 51 ++++----- tests/rigctl_parse.c | 77 +++++++------- 3 files changed, 190 insertions(+), 185 deletions(-) diff --git a/tests/dumpstate.c b/tests/dumpstate.c index d2fb9a794..fdae1a376 100644 --- a/tests/dumpstate.c +++ b/tests/dumpstate.c @@ -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))); diff --git a/tests/memload.c b/tests/memload.c index a37c6af28..e4e4eb689 100644 --- a/tests/memload.c +++ b/tests/memload.c @@ -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"); diff --git a/tests/rigctl_parse.c b/tests/rigctl_parse.c index 5b8333c12..cc2c3f761 100644 --- a/tests/rigctl_parse.c +++ b/tests/rigctl_parse.c @@ -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)); }