SW/DSView
2
0
Fork 0
forked from Ivasoft/DSView
Code Pull Requests Activity

The print format for type uint64_t

Browse Source
This commit is contained in:
dreamsourcelabTAI
2023-06-29 16:47:00 +08:00
parent c8d226bd04
commit dc70371195
12 changed files with 50 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
DSView/main.cpp
View File

@@ -37,6 +37,7 @@
#include "pv/ui/langresource.h" #include "pv/ui/langresource.h"
#include <QDateTime> #include <QDateTime>
#include <string> #include <string>
#include <ds_types.h>
#ifdef _WIN32 #ifdef _WIN32
#include <windows.h> #include <windows.h>
@@ -216,7 +217,7 @@ bool bHighScale = true;
std::string strTime = dateTime .toString("yyyy-MM-dd hh:mm:ss").toStdString(); std::string strTime = dateTime .toString("yyyy-MM-dd hh:mm:ss").toStdString();
dsv_info("%s", strTime.c_str()); dsv_info("%s", strTime.c_str());
int bit_width = sizeof(long); int bit_width = sizeof(u64_t);
if (bit_width != 8){ if (bit_width != 8){
dsv_err("Can only run on 64 bit systems"); dsv_err("Can only run on 64 bit systems");
return 0; return 0;

10
DSView/pv/data/decoderstack.cpp
View File

@@ -34,8 +34,8 @@
#include "../view/logicsignal.h" #include "../view/logicsignal.h"
#include "../dsvdef.h" #include "../dsvdef.h"
#include "../log.h" #include "../log.h"
#include "../ui/langresource.h" #include "../ui/langresource.h"
#include <ds_types.h>
using namespace pv::data::decode; using namespace pv::data::decode;
using namespace std; using namespace std;
@@ -551,7 +551,8 @@ void DecoderStack::decode_data(const uint64_t decode_start, const uint64_t decod
if (end_index >= align_sample_count){ if (end_index >= align_sample_count){
end_index = align_sample_count - 1; end_index = align_sample_count - 1;
dsv_info("Reset the decode end sample, new:%lu, old:%lu", end_index, decode_end); dsv_info("Reset the decode end sample, new:%llu, old:%llu",
(u64_t)end_index, (u64_t)decode_end);
} }
} }
} }
@@ -660,7 +661,7 @@ void DecoderStack::decode_data(const uint64_t decode_start, const uint64_t decod
} }
} }
dsv_info("%s%lu", "send to decoder times: ", entry_cnt); dsv_info("%s%llu", "send to decoder times: ", (u64_t)entry_cnt);
if (error != NULL) if (error != NULL)
g_free(error); g_free(error);
@@ -716,7 +717,8 @@ void DecoderStack::execute_decode_stack()
decode_end = max(dec->decode_end(), decode_end); decode_end = max(dec->decode_end(), decode_end);
} }
dsv_info("decoder start sample:%lu, end sample:%lu, count:%lu", decode_start, decode_end, decode_end - decode_start + 1); dsv_info("decoder start sample:%llu, end sample:%llu, count:%llu",
(u64_t)decode_start, (u64_t)decode_end, (u64_t)(decode_end - decode_start + 1));
// Start the session // Start the session
srd_session_metadata_set(session, SRD_CONF_SAMPLERATE, srd_session_metadata_set(session, SRD_CONF_SAMPLERATE,

1
DSView/pv/prop/binding/decoderoptions.cpp
View File

@@ -46,6 +46,7 @@ DecoderOptions::DecoderOptions(pv::data::DecoderStack* decoder_stack, data::deco
_decoder(decoder) _decoder(decoder)
{ {
assert(_decoder); assert(_decoder);
(void)decoder_stack;
const srd_decoder *const dec = _decoder->decoder(); const srd_decoder *const dec = _decoder->decoder();
assert(dec); assert(dec);

2
common/ds_types.h
View File

@@ -30,6 +30,6 @@
#ifndef _DS_TYPES_H #ifndef _DS_TYPES_H
#define _DS_TYPES_H #define _DS_TYPES_H
typedef unsigned long u64_t; typedef unsigned long long u64_t;
#endif #endif

4
libsigrok4DSL/hardware/DSL/dsl.c
View File

@@ -2309,7 +2309,7 @@ static void receive_transfer(struct libusb_transfer *transfer)
if (devc->abort) if (devc->abort)
devc->status = DSL_STOP; devc->status = DSL_STOP;
sr_detail("%lu: receive_transfer(): status %d; timeout %d; received %d bytes.", sr_detail("%llu: receive_transfer(): status %d; timeout %d; received %d bytes.",
(u64_t)g_get_monotonic_time(), transfer->status, transfer->timeout, transfer->actual_length); (u64_t)g_get_monotonic_time(), transfer->status, transfer->timeout, transfer->actual_length);
switch (transfer->status) { switch (transfer->status) {
@@ -2441,7 +2441,7 @@ static void receive_header(struct libusb_transfer *transfer)
devc->status = DSL_ERROR; devc->status = DSL_ERROR;
if (!devc->abort && transfer->status == LIBUSB_TRANSFER_COMPLETED && if (!devc->abort && transfer->status == LIBUSB_TRANSFER_COMPLETED &&
trigger_pos->check_id == TRIG_CHECKID) { trigger_pos->check_id == TRIG_CHECKID) {
sr_info("%lu: receive_trigger_pos(): status %d; timeout %d; received %d bytes.", sr_info("%llu: receive_trigger_pos(): status %d; timeout %d; received %d bytes.",
(u64_t)g_get_monotonic_time(), transfer->status, transfer->timeout, transfer->actual_length); (u64_t)g_get_monotonic_time(), transfer->status, transfer->timeout, transfer->actual_length);
remain_cnt = trigger_pos->remain_cnt_h; remain_cnt = trigger_pos->remain_cnt_h;
remain_cnt = (remain_cnt << 32) + trigger_pos->remain_cnt_l; remain_cnt = (remain_cnt << 32) + trigger_pos->remain_cnt_l;

6
libsigrok4DSL/hardware/demo/demo.c
View File

@@ -919,11 +919,11 @@ static int config_set(int id, GVariant *data, struct sr_dev_inst *sdi,
{ {
case SR_CONF_SAMPLERATE: case SR_CONF_SAMPLERATE:
vdev->samplerate = g_variant_get_uint64(data); vdev->samplerate = g_variant_get_uint64(data);
sr_dbg("Setting samplerate to %lu.", (u64_t)vdev->samplerate); sr_dbg("Setting samplerate to %llu.", (u64_t)vdev->samplerate);
break; break;
case SR_CONF_LIMIT_SAMPLES: case SR_CONF_LIMIT_SAMPLES:
vdev->total_samples = g_variant_get_uint64(data); vdev->total_samples = g_variant_get_uint64(data);
sr_dbg("Setting limit samples to %lu.", (u64_t)vdev->total_samples); sr_dbg("Setting limit samples to %llu.", (u64_t)vdev->total_samples);
break; break;
case SR_CONF_LIMIT_MSEC: case SR_CONF_LIMIT_MSEC:
break; break;
@@ -1034,7 +1034,7 @@ static int config_set(int id, GVariant *data, struct sr_dev_inst *sdi,
g_timer_start(run_time); g_timer_start(run_time);
vdev->timebase_change = TRUE; vdev->timebase_change = TRUE;
} }
sr_dbg("Setting timebase to %lu.", (u64_t)vdev->timebase); sr_dbg("Setting timebase to %llu.", (u64_t)vdev->timebase);
break; break;
case SR_CONF_PROBE_COUPLING: case SR_CONF_PROBE_COUPLING:
if(sdi->mode != LOGIC) if(sdi->mode != LOGIC)

6
libsigrok4DSL/input/in_vcd.c
View File

@@ -236,11 +236,11 @@ static gboolean parse_header(FILE *file, struct context *ctx)
if (q % p != 0) if (q % p != 0)
{ {
/* Does not happen unless time value is non-standard */ /* Does not happen unless time value is non-standard */
sr_warn("Inexact rounding of samplerate, %lu / %lu to %lu Hz.", sr_warn("Inexact rounding of samplerate, %llu / %llu to %llu Hz.",
(u64_t)q, (u64_t)p, (u64_t)ctx->samplerate); (u64_t)q, (u64_t)p, (u64_t)ctx->samplerate);
} }
sr_dbg("Samplerate: %lu", (u64_t)ctx->samplerate); sr_dbg("Samplerate: %llu", (u64_t)ctx->samplerate);
} }
else else
{ {
@@ -476,7 +476,7 @@ static void parse_contents(FILE *file, const struct sr_dev_inst *sdi, struct con
prev_timestamp = timestamp - ctx->compress; prev_timestamp = timestamp - ctx->compress;
} }
sr_dbg("New timestamp: %lu", (u64_t)timestamp); sr_dbg("New timestamp: %llu", (u64_t)timestamp);
/* Generate samples from prev_timestamp up to timestamp - 1. */ /* Generate samples from prev_timestamp up to timestamp - 1. */
send_samples(sdi, prev_values, timestamp - prev_timestamp); send_samples(sdi, prev_values, timestamp - prev_timestamp);

2
libsigrok4DSL/output/gnuplot.c
View File

@@ -212,7 +212,7 @@ static int receive(const struct sr_output *o, const struct sr_datafeed_packet *p
memcpy(ctx->prevsample, sample, logic->unitsize); memcpy(ctx->prevsample, sample, logic->unitsize);
/* The first column is a counter (needed for gnuplot). */ /* The first column is a counter (needed for gnuplot). */
g_string_append_printf(*out, "%lu\t", (u64_t)ctx->samplecount-1); g_string_append_printf(*out, "%llu\t", (u64_t)ctx->samplecount-1);
/* The next columns are the values of all channels. */ /* The next columns are the values of all channels. */
for (p = 0; p < ctx->num_enabled_channels; p++) { for (p = 0; p < ctx->num_enabled_channels; p++) {

2
libsigrok4DSL/session.c
View File

@@ -290,7 +290,7 @@ static void datafeed_dump(const struct sr_datafeed_packet *packet)
break; break;
case SR_DF_LOGIC: case SR_DF_LOGIC:
logic = packet->payload; logic = packet->payload;
sr_dbg("bus: Received SR_DF_LOGIC packet (%lu bytes).", sr_dbg("bus: Received SR_DF_LOGIC packet (%llu bytes).",
(u64_t)logic->length); (u64_t)logic->length);
break; break;
case SR_DF_DSO: case SR_DF_DSO:

16
libsigrok4DSL/session_driver.c
View File

@@ -1072,19 +1072,19 @@ static int config_set(int id, GVariant *data, struct sr_dev_inst *sdi,
case SR_CONF_SAMPLERATE: case SR_CONF_SAMPLERATE:
vdev->samplerate = g_variant_get_uint64(data); vdev->samplerate = g_variant_get_uint64(data);
samplerates[0] = vdev->samplerate; samplerates[0] = vdev->samplerate;
sr_dbg("Setting samplerate to %lu.", (u64_t)vdev->samplerate); sr_dbg("Setting samplerate to %llu.", (u64_t)vdev->samplerate);
break; break;
case SR_CONF_TIMEBASE: case SR_CONF_TIMEBASE:
vdev->timebase = g_variant_get_uint64(data); vdev->timebase = g_variant_get_uint64(data);
sr_dbg("Setting timebase to %lu.", (u64_t)vdev->timebase); sr_dbg("Setting timebase to %llu.", (u64_t)vdev->timebase);
break; break;
case SR_CONF_MAX_TIMEBASE: case SR_CONF_MAX_TIMEBASE:
vdev->max_timebase = g_variant_get_uint64(data); vdev->max_timebase = g_variant_get_uint64(data);
sr_dbg("Setting max timebase to %lu.", (u64_t)vdev->max_timebase); sr_dbg("Setting max timebase to %llu.", (u64_t)vdev->max_timebase);
break; break;
case SR_CONF_MIN_TIMEBASE: case SR_CONF_MIN_TIMEBASE:
vdev->min_timebase = g_variant_get_uint64(data); vdev->min_timebase = g_variant_get_uint64(data);
sr_dbg("Setting min timebase to %lu.", (u64_t)vdev->min_timebase); sr_dbg("Setting min timebase to %llu.", (u64_t)vdev->min_timebase);
break; break;
case SR_CONF_UNIT_BITS: case SR_CONF_UNIT_BITS:
vdev->unit_bits = g_variant_get_byte(data); vdev->unit_bits = g_variant_get_byte(data);
@@ -1105,19 +1105,19 @@ static int config_set(int id, GVariant *data, struct sr_dev_inst *sdi,
case SR_CONF_LIMIT_SAMPLES: case SR_CONF_LIMIT_SAMPLES:
vdev->total_samples = g_variant_get_uint64(data); vdev->total_samples = g_variant_get_uint64(data);
samplecounts[0] = vdev->total_samples; samplecounts[0] = vdev->total_samples;
sr_dbg("Setting limit samples to %lu.", (u64_t)vdev->total_samples); sr_dbg("Setting limit samples to %llu.", (u64_t)vdev->total_samples);
break; break;
case SR_CONF_TRIGGER_TIME: case SR_CONF_TRIGGER_TIME:
vdev->trig_time = g_variant_get_int64(data); vdev->trig_time = g_variant_get_int64(data);
sr_dbg("Setting trigger time to %lu.", (u64_t)vdev->trig_time); sr_dbg("Setting trigger time to %llu.", (u64_t)vdev->trig_time);
break; break;
case SR_CONF_TRIGGER_POS: case SR_CONF_TRIGGER_POS:
vdev->trig_pos = g_variant_get_uint64(data); vdev->trig_pos = g_variant_get_uint64(data);
sr_dbg("Setting trigger position to %lu.", (u64_t)vdev->trig_pos); sr_dbg("Setting trigger position to %llu.", (u64_t)vdev->trig_pos);
break; break;
case SR_CONF_NUM_BLOCKS: case SR_CONF_NUM_BLOCKS:
vdev->num_blocks = g_variant_get_uint64(data); vdev->num_blocks = g_variant_get_uint64(data);
sr_dbg("Setting block number to %lu.", (u64_t)vdev->num_blocks); sr_dbg("Setting block number to %llu.", (u64_t)vdev->num_blocks);
break; break;
case SR_CONF_CAPTURE_NUM_PROBES: case SR_CONF_CAPTURE_NUM_PROBES:
vdev->num_probes = g_variant_get_uint64(data); vdev->num_probes = g_variant_get_uint64(data);

42
libsigrok4DSL/strutil.c
View File

@@ -62,24 +62,24 @@ SR_API char *sr_si_string_u64(uint64_t x, const char *unit)
unit = ""; unit = "";
if ((x >= SR_GHZ(1)) && (x % SR_GHZ(1) == 0)) { if ((x >= SR_GHZ(1)) && (x % SR_GHZ(1) == 0)) {
return g_strdup_printf("%lu G%s", (u64_t)(x / SR_GHZ(1)), unit); return g_strdup_printf("%llu G%s", (u64_t)(x / SR_GHZ(1)), unit);
} else if ((x >= SR_GHZ(1)) && (x % SR_GHZ(1) != 0)) { } else if ((x >= SR_GHZ(1)) && (x % SR_GHZ(1) != 0)) {
return g_strdup_printf("%lu.%lu G%s", return g_strdup_printf("%llu.%llu G%s",
(u64_t)(x / SR_GHZ(1)), (u64_t)(x % SR_GHZ(1)), unit); (u64_t)(x / SR_GHZ(1)), (u64_t)(x % SR_GHZ(1)), unit);
} else if ((x >= SR_MHZ(1)) && (x % SR_MHZ(1) == 0)) { } else if ((x >= SR_MHZ(1)) && (x % SR_MHZ(1) == 0)) {
return g_strdup_printf("%lu M%s", return g_strdup_printf("%llu M%s",
(u64_t)(x / SR_MHZ(1)), unit); (u64_t)(x / SR_MHZ(1)), unit);
} else if ((x >= SR_MHZ(1)) && (x % SR_MHZ(1) != 0)) { } else if ((x >= SR_MHZ(1)) && (x % SR_MHZ(1) != 0)) {
return g_strdup_printf("%lu.%lu M%s", return g_strdup_printf("%llu.%llu M%s",
(u64_t)(x / SR_MHZ(1)), (u64_t)(x % SR_MHZ(1)), unit); (u64_t)(x / SR_MHZ(1)), (u64_t)(x % SR_MHZ(1)), unit);
} else if ((x >= SR_KHZ(1)) && (x % SR_KHZ(1) == 0)) { } else if ((x >= SR_KHZ(1)) && (x % SR_KHZ(1) == 0)) {
return g_strdup_printf("%lu k%s", return g_strdup_printf("%llu k%s",
(u64_t)(x / SR_KHZ(1)), unit); (u64_t)(x / SR_KHZ(1)), unit);
} else if ((x >= SR_KHZ(1)) && (x % SR_KHZ(1) != 0)) { } else if ((x >= SR_KHZ(1)) && (x % SR_KHZ(1) != 0)) {
return g_strdup_printf("%lu.%lu K%s", return g_strdup_printf("%llu.%llu K%s",
(u64_t)(x / SR_KHZ(1)), (u64_t)(x % SR_KHZ(1)), unit); (u64_t)(x / SR_KHZ(1)), (u64_t)(x % SR_KHZ(1)), unit);
} else { } else {
return g_strdup_printf("%lu %s", (u64_t)x, unit); return g_strdup_printf("%llu %s", (u64_t)x, unit);
} }
sr_err("%s: Error creating SI units string.", __func__); sr_err("%s: Error creating SI units string.", __func__);
@@ -107,24 +107,24 @@ SR_API char *sr_iec_string_u64(uint64_t x, const char *unit)
unit = ""; unit = "";
if ((x >= SR_GB(1)) && (x % SR_GB(1) == 0)) { if ((x >= SR_GB(1)) && (x % SR_GB(1) == 0)) {
return g_strdup_printf("%lu G%s", (u64_t)(x / SR_GB(1)), unit); return g_strdup_printf("%llu G%s", (u64_t)(x / SR_GB(1)), unit);
} else if ((x >= SR_GB(1)) && (x % SR_GB(1) != 0)) { } else if ((x >= SR_GB(1)) && (x % SR_GB(1) != 0)) {
return g_strdup_printf("%lu.%lu G%s", return g_strdup_printf("%llu.%llu G%s",
(u64_t)(x / SR_GB(1)), (u64_t)(x % SR_GB(1)), unit); (u64_t)(x / SR_GB(1)), (u64_t)(x % SR_GB(1)), unit);
} else if ((x >= SR_MB(1)) && (x % SR_MB(1) == 0)) { } else if ((x >= SR_MB(1)) && (x % SR_MB(1) == 0)) {
return g_strdup_printf("%lu M%s", return g_strdup_printf("%llu M%s",
(u64_t)(x / SR_MB(1)), unit); (u64_t)(x / SR_MB(1)), unit);
} else if ((x >= SR_MB(1)) && (x % SR_MB(1) != 0)) { } else if ((x >= SR_MB(1)) && (x % SR_MB(1) != 0)) {
return g_strdup_printf("%lu.%lu M%s", return g_strdup_printf("%llu.%llu M%s",
(u64_t)(x / SR_MB(1)), (u64_t)(x % SR_MB(1)), unit); (u64_t)(x / SR_MB(1)), (u64_t)(x % SR_MB(1)), unit);
} else if ((x >= SR_KB(1)) && (x % SR_KB(1) == 0)) { } else if ((x >= SR_KB(1)) && (x % SR_KB(1) == 0)) {
return g_strdup_printf("%lu k%s", return g_strdup_printf("%llu k%s",
(u64_t)(x / SR_KB(1)), unit); (u64_t)(x / SR_KB(1)), unit);
} else if ((x >= SR_KB(1)) && (x % SR_KB(1) != 0)) { } else if ((x >= SR_KB(1)) && (x % SR_KB(1) != 0)) {
return g_strdup_printf("%lu.%lu K%s", return g_strdup_printf("%llu.%llu K%s",
(u64_t)(x / SR_KB(1)), (u64_t)(x % SR_KB(1)), unit); (u64_t)(x / SR_KB(1)), (u64_t)(x % SR_KB(1)), unit);
} else { } else {
return g_strdup_printf("%lu %s", (u64_t)x, unit); return g_strdup_printf("%llu %s", (u64_t)x, unit);
} }
sr_err("%s: Error creating SI units string.", __func__); sr_err("%s: Error creating SI units string.", __func__);
@@ -188,13 +188,13 @@ SR_API char *sr_period_string(uint64_t frequency)
} }
if (frequency >= SR_GHZ(1)) if (frequency >= SR_GHZ(1))
r = snprintf(o, 30, "%lu ns", (u64_t)(frequency / 1000000000)); r = snprintf(o, 30, "%llu ns", (u64_t)(frequency / 1000000000));
else if (frequency >= SR_MHZ(1)) else if (frequency >= SR_MHZ(1))
r = snprintf(o, 30, "%lu us", (u64_t)(frequency / 1000000)); r = snprintf(o, 30, "%llu us", (u64_t)(frequency / 1000000));
else if (frequency >= SR_KHZ(1)) else if (frequency >= SR_KHZ(1))
r = snprintf(o, 30, "%lu ms", (u64_t)(frequency / 1000)); r = snprintf(o, 30, "%llu ms", (u64_t)(frequency / 1000));
else else
r = snprintf(o, 30, "%lu s", (u64_t)frequency); r = snprintf(o, 30, "%llu s", (u64_t)frequency);
if (r < 0) { if (r < 0) {
/* Something went wrong... */ /* Something went wrong... */
@@ -241,7 +241,7 @@ SR_API char *sr_time_string(uint64_t time)
else if (time >= SR_US(1)) else if (time >= SR_US(1))
r = snprintf(o, 30, "%0.2lf us", time * 1.0 / SR_US(1)); r = snprintf(o, 30, "%0.2lf us", time * 1.0 / SR_US(1));
else else
r = snprintf(o, 30, "%lu ns", (u64_t)time); r = snprintf(o, 30, "%llu ns", (u64_t)time);
if (r < 0) { if (r < 0) {
/* Something went wrong... */ /* Something went wrong... */
@@ -277,9 +277,9 @@ SR_API char *sr_voltage_string(uint64_t v_p, uint64_t v_q)
} }
if (v_q == 1000) if (v_q == 1000)
r = snprintf(o, 30, "%lumV", (u64_t)v_p); r = snprintf(o, 30, "%llumV", (u64_t)v_p);
else if (v_q == 1) else if (v_q == 1)
r = snprintf(o, 30, "%luV", (u64_t)v_p); r = snprintf(o, 30, "%lluV", (u64_t)v_p);
else else
r = snprintf(o, 30, "%gV", (float)v_p / (float)v_q); r = snprintf(o, 30, "%gV", (float)v_p / (float)v_q);

2
libsigrok4DSL/tests/lib.c
View File

@@ -117,6 +117,6 @@ void srtest_check_samplerate(struct sr_context *sr_ctx, const char *drivername,
srtest_driver_init(sr_ctx, driver);; srtest_driver_init(sr_ctx, driver);;
srtest_set_samplerate(driver, samplerate); srtest_set_samplerate(driver, samplerate);
s = srtest_get_samplerate(driver); s = srtest_get_samplerate(driver);
fail_unless(s == samplerate, "%s: Incorrect samplerate: %lu.", fail_unless(s == samplerate, "%s: Incorrect samplerate: %llu.",
drivername, (u64_t)s); drivername, (u64_t)s);
} }