[beast: 17/22] BSE: use Rapicorn's assert() instead of g_assert()
- From: Tim Janik <timj src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [beast: 17/22] BSE: use Rapicorn's assert() instead of g_assert()
- Date: Thu, 24 Sep 2015 20:10:23 +0000 (UTC)
commit d771ce385e6708659d12c965e602fb47b32415a5
Author: Tim Janik <timj gnu org>
Date: Mon Sep 21 20:34:05 2015 +0200
BSE: use Rapicorn's assert() instead of g_assert()
bse/bsebiquadfilter.cc | 10 +++++-----
bse/bsebus.cc | 18 +++++++++---------
bse/bseconstant.cc | 2 +-
bse/bsecontainer.cc | 2 +-
bse/bsecontextmerger.cc | 4 ++--
bse/bsecxxbase.cc | 6 +++---
bse/bsecxxplugin.hh | 2 +-
bse/bsecxxutils.hh | 2 +-
bse/bsedatahandle-fir.cc | 2 +-
bse/bsedatahandle-resample.cc | 8 ++++----
bse/bsedatapocket.cc | 2 +-
bse/bsedevice.cc | 2 +-
bse/bseeditablesample.cc | 2 +-
bse/bseengine.cc | 8 ++++----
bse/bseenginemaster.cc | 8 ++++----
bse/bseengineschedule.cc | 26 +++++++++++++-------------
bse/bseengineutils.cc | 12 ++++++------
bse/bsegconfig.cc | 2 +-
bse/bseinstrumentinput.cc | 10 +++++-----
bse/bseinstrumentoutput.cc | 10 +++++-----
bse/bseitem.cc | 2 +-
bse/bseladspamodule.cc | 6 +++---
bse/bseloader-aiff.cc | 2 +-
bse/bseloader-bsewave.cc | 4 ++--
bse/bseloader-flac.cc | 2 +-
bse/bseloader-guspatch.cc | 2 +-
bse/bseloader-mad.cc | 2 +-
bse/bseloader-oggvorbis.cc | 2 +-
bse/bseloader-wav.cc | 8 ++++----
bse/bsemain.cc | 2 +-
bse/bsemidicontroller.cc | 8 ++++----
bse/bsemididecoder.cc | 2 +-
bse/bsemididevice-null.cc | 2 +-
bse/bsemididevice-oss.cc | 4 ++--
bse/bsemidiinput.cc | 8 ++++----
bse/bsemidireceiver.cc | 6 +++---
bse/bsemidivoice.cc | 20 ++++++++++----------
bse/bseobject.cc | 2 +-
bse/bseparasite.cc | 4 ++--
bse/bsepart.cc | 16 ++++++++--------
bse/bsepcminput.cc | 4 ++--
bse/bsepcmoutput.cc | 4 ++--
bse/bseplugin.cc | 2 +-
bse/bseprobe.cc | 30 +++++++++++++++---------------
bse/bseprocedure.cc | 2 +-
bse/bseresampler.hh | 2 +-
bse/bseresamplerimpl.hh | 6 +++---
bse/bsesequencer.cc | 8 ++++----
bse/bseserver.cc | 6 +++---
bse/bsesnet.cc | 8 ++++----
bse/bsesnooper.cc | 2 +-
bse/bsesong.cc | 4 ++--
bse/bsesource.cc | 4 ++--
bse/bsestandardosc.cc | 12 ++++++------
bse/bsestorage.cc | 2 +-
bse/bsesubiport.cc | 2 +-
bse/bsesuboport.cc | 2 +-
bse/bsesubsynth.cc | 6 +++---
bse/bsetrack.cc | 14 +++++++-------
bse/bsetype.cc | 2 +-
bse/bsewaveosc.cc | 12 ++++++------
bse/gsldatacache.cc | 6 +++---
bse/gsldatahandle-mad.cc | 2 +-
bse/gsldatahandle-vorbis.cc | 2 +-
bse/gsldatahandle.cc | 2 +-
bse/gsldatautils.cc | 6 +++---
bse/gslfilehash.cc | 2 +-
bse/gslvorbis-enc.cc | 2 +-
bse/gslwavechunk.cc | 4 ++--
bse/gslwaveosc.cc | 6 +++---
bse/tests/blocktests.cc | 12 ++++++------
bse/tests/firhandle.cc | 12 ++++++------
bse/tests/resamplehandle.cc | 6 +++---
bse/tests/subnormals.cc | 12 ++++++------
74 files changed, 225 insertions(+), 225 deletions(-)
---
diff --git a/bse/bsebiquadfilter.cc b/bse/bsebiquadfilter.cc
index 93944bf..178f449 100644
--- a/bse/bsebiquadfilter.cc
+++ b/bse/bsebiquadfilter.cc
@@ -169,15 +169,15 @@ bse_biquad_filter_class_init (BseBiquadFilterClass *klass)
SFI_PARAM_STANDARD ":scale"));
channel_id = bse_source_class_add_ichannel (source_class, "audio-in", _("Audio In"), _("Unfiltered Audio
Signal"));
- g_assert (channel_id == BSE_BIQUAD_FILTER_ICHANNEL_AUDIO);
+ assert (channel_id == BSE_BIQUAD_FILTER_ICHANNEL_AUDIO);
channel_id = bse_source_class_add_ichannel (source_class, "freq-in", _("Freq In"), _("Center Frequency
Input"));
- g_assert (channel_id == BSE_BIQUAD_FILTER_ICHANNEL_FREQ);
+ assert (channel_id == BSE_BIQUAD_FILTER_ICHANNEL_FREQ);
channel_id = bse_source_class_add_ichannel (source_class, "freq-mod-in", _("Freq Mod In"), _("Frequency
Modulation Input"));
- g_assert (channel_id == BSE_BIQUAD_FILTER_ICHANNEL_FREQ_MOD);
+ assert (channel_id == BSE_BIQUAD_FILTER_ICHANNEL_FREQ_MOD);
channel_id = bse_source_class_add_ichannel (source_class, "gain-mod-in", _("Gain Mod In"), _("Gain
Modulation Input"));
- g_assert (channel_id == BSE_BIQUAD_FILTER_ICHANNEL_GAIN_MOD);
+ assert (channel_id == BSE_BIQUAD_FILTER_ICHANNEL_GAIN_MOD);
channel_id = bse_source_class_add_ochannel (source_class, "audio-out", _("Audio Out"), _("Filtered Audio
Signal"));
- g_assert (channel_id == BSE_BIQUAD_FILTER_OCHANNEL_AUDIO);
+ assert (channel_id == BSE_BIQUAD_FILTER_OCHANNEL_AUDIO);
}
static void
diff --git a/bse/bsebus.cc b/bse/bsebus.cc
index 751a5f2..64b2d83 100644
--- a/bse/bsebus.cc
+++ b/bse/bsebus.cc
@@ -60,16 +60,16 @@ bse_bus_dispose (GObject *object)
/* chain parent class' handler */
G_OBJECT_CLASS (bus_parent_class)->dispose (object);
- g_assert (self->bus_outputs == NULL);
+ assert (self->bus_outputs == NULL);
}
static void
bse_bus_finalize (GObject *object)
{
BseBus *self = BSE_BUS (object);
- g_assert (self->inputs == NULL);
- g_assert (self->bus_outputs == NULL);
- g_assert (self->summation == NULL);
+ assert (self->inputs == NULL);
+ assert (self->bus_outputs == NULL);
+ assert (self->summation == NULL);
/* chain parent class' handler */
G_OBJECT_CLASS (bus_parent_class)->finalize (object);
}
@@ -560,7 +560,7 @@ bse_bus_get_stack (BseBus *self,
BseProject *project = bse_item_get_project (item);
if (!BSE_SUB_SYNTH (self)->snet && project && BSE_IS_SONG (item->parent))
{
- g_assert (self->n_effects == 0);
+ assert (self->n_effects == 0);
bse_bus_ensure_summation (self);
BseSNet *snet = (BseSNet*) bse_project_create_intern_csynth (project, "%BusEffectStack");
self->vin = (BseSource*) bse_container_new_child_bname (BSE_CONTAINER (snet), BSE_TYPE_SUB_IPORT,
"%VInput", NULL);
@@ -898,13 +898,13 @@ bse_bus_class_init (BseBusClass *klass)
FALSE, SFI_PARAM_STORAGE ":skip-default"));
channel_id = bse_source_class_add_ichannel (source_class, "left-audio-in", _("Left Audio In"), _("Left
channel input"));
- g_assert (channel_id == BSE_BUS_ICHANNEL_LEFT);
+ assert (channel_id == BSE_BUS_ICHANNEL_LEFT);
channel_id = bse_source_class_add_ichannel (source_class, "right-audio-in", _("Right Audio In"), _("Right
channel input"));
- g_assert (channel_id == BSE_BUS_ICHANNEL_RIGHT);
+ assert (channel_id == BSE_BUS_ICHANNEL_RIGHT);
channel_id = bse_source_class_add_ochannel (source_class, "left-audio-out", _("Left Audio Out"), _("Left
channel output"));
- g_assert (channel_id == BSE_BUS_OCHANNEL_LEFT);
+ assert (channel_id == BSE_BUS_OCHANNEL_LEFT);
channel_id = bse_source_class_add_ochannel (source_class, "right-audio-out", _("Right Audio Out"),
_("Right channel output"));
- g_assert (channel_id == BSE_BUS_OCHANNEL_RIGHT);
+ assert (channel_id == BSE_BUS_OCHANNEL_RIGHT);
}
BSE_BUILTIN_TYPE (BseBus)
diff --git a/bse/bseconstant.cc b/bse/bseconstant.cc
index 262b39d..e4f19c2 100644
--- a/bse/bseconstant.cc
+++ b/bse/bseconstant.cc
@@ -120,7 +120,7 @@ bse_constant_class_init (BseConstantClass *klass)
label = g_strdup_format (_("Const Out%u"), i);
blurb = g_strdup_format (_("Constant Output %u"), i);
ochannel = bse_source_class_add_ochannel (source_class, ident, label, blurb);
- g_assert (ochannel == i - 1);
+ assert (ochannel == i - 1);
g_free (ident);
g_free (label);
g_free (blurb);
diff --git a/bse/bsecontainer.cc b/bse/bsecontainer.cc
index 2881ff2..e19201d 100644
--- a/bse/bsecontainer.cc
+++ b/bse/bsecontainer.cc
@@ -760,7 +760,7 @@ uncross_link_R (BseContainerCrossLinks *clinks,
unode.next = uncross_stack;
uncross_stack = &unode;
unode.uncross (unode.owner, unode.link); /* may recurse */
- g_assert (uncross_stack == &unode); /* paranoid */
+ assert (uncross_stack == &unode); /* paranoid */
uncross_stack = unode.next;
}
}
diff --git a/bse/bsecontextmerger.cc b/bse/bsecontextmerger.cc
index cf59a9c..f394c2c 100644
--- a/bse/bsecontextmerger.cc
+++ b/bse/bsecontextmerger.cc
@@ -62,12 +62,12 @@ bse_context_merger_class_init (BseContextMergerClass *klass)
ident = g_strdup_format ("input-%u", i + 1);
channel_id = bse_source_class_add_jchannel (source_class, ident, NULL, NULL);
- g_assert (channel_id == i);
+ assert (channel_id == i);
g_free (ident);
ident = g_strdup_format ("output-%u", i + 1);
channel_id = bse_source_class_add_ochannel (source_class, ident, NULL, NULL);
- g_assert (channel_id == i);
+ assert (channel_id == i);
g_free (ident);
}
}
diff --git a/bse/bsecxxbase.cc b/bse/bsecxxbase.cc
index 598007a..dbe46b6 100644
--- a/bse/bsecxxbase.cc
+++ b/bse/bsecxxbase.cc
@@ -307,7 +307,7 @@ CxxBaseClass::add_ochannel (const char *ident,
{
int channel_id = bse_source_class_add_ochannel ((BseSourceClass*) this, ident, label, blurb);
if (assert_id >= 0)
- g_assert (assert_id == channel_id);
+ assert (assert_id == channel_id);
}
void
@@ -318,7 +318,7 @@ CxxBaseClass::add_ichannel (const char *ident,
{
int channel_id = bse_source_class_add_ichannel ((BseSourceClass*) this, ident, label, blurb);
if (assert_id >= 0)
- g_assert (assert_id == channel_id);
+ assert (assert_id == channel_id);
}
void
@@ -329,7 +329,7 @@ CxxBaseClass::add_jchannel (const char *ident,
{
int channel_id = bse_source_class_add_jchannel ((BseSourceClass*) this, ident, label, blurb);
if (assert_id >= 0)
- g_assert (assert_id == channel_id);
+ assert (assert_id == channel_id);
}
} // Bse
diff --git a/bse/bsecxxplugin.hh b/bse/bsecxxplugin.hh
index 874855d..60636bb 100644
--- a/bse/bsecxxplugin.hh
+++ b/bse/bsecxxplugin.hh
@@ -121,7 +121,7 @@ extern ::BseExportIdentity bse_builtin_export_identity; /* sync with bseplugin.h
if (!values[0].value_name) { \
GEnumValue *v = values; \
ICode; /* initializes values via *v++ = ...; */ \
- g_assert (v == values + N); \
+ assert (v == values + N); \
*v++ = ::Bse::EnumValue (0, 0, 0); /* NULL termination */ \
} \
return values; \
diff --git a/bse/bsecxxutils.hh b/bse/bsecxxutils.hh
index c667531..3f21389 100644
--- a/bse/bsecxxutils.hh
+++ b/bse/bsecxxutils.hh
@@ -158,7 +158,7 @@ bse_type_id_wrapper (const char *type_name)
if (!type)
{
type = g_type_from_name (type_name);
- g_assert (type);
+ assert (type);
}
return type;
}
diff --git a/bse/bsedatahandle-fir.cc b/bse/bsedatahandle-fir.cc
index b17b725..d98b158 100644
--- a/bse/bsedatahandle-fir.cc
+++ b/bse/bsedatahandle-fir.cc
@@ -174,7 +174,7 @@ public:
return l;
}
- g_assert (ivoffset == m_input_voffset);
+ assert (ivoffset == m_input_voffset);
voffset -= ivoffset;
n_values = min (n_values, m_block_size - voffset);
diff --git a/bse/bsedatahandle-resample.cc b/bse/bsedatahandle-resample.cc
index 16e3e52..076012e 100644
--- a/bse/bsedatahandle-resample.cc
+++ b/bse/bsedatahandle-resample.cc
@@ -153,11 +153,11 @@ public:
for (guint i = 0; i < setup->n_channels; i++)
{
Resampler2 *resampler = Resampler2::create (mode(), precision);
- g_assert (resampler);
+ assert (resampler);
m_resamplers.push_back (resampler);
}
- g_assert (!m_resamplers.empty()); /* n_channels is always > 0 */
+ assert (!m_resamplers.empty()); /* n_channels is always > 0 */
m_filter_order = m_resamplers[0]->order();
/* Resampler2::delay() is defined in output samples, but we need to
@@ -209,10 +209,10 @@ public:
if (l < 0)
return l;
}
- g_assert (m_pcm_frame == frame);
+ assert (m_pcm_frame == frame);
voffset -= m_pcm_frame * m_frame_size;
- g_assert (voffset >= 0);
+ assert (voffset >= 0);
n_values = std::min (n_values, m_frame_size - voffset);
for (int64 i = 0; i < n_values; i++)
diff --git a/bse/bsedatapocket.cc b/bse/bsedatapocket.cc
index acfd57a..68fe5ec 100644
--- a/bse/bsedatapocket.cc
+++ b/bse/bsedatapocket.cc
@@ -276,7 +276,7 @@ _bse_data_pocket_create_entry (BseDataPocket *pocket)
assert_return (BSE_IS_DATA_POCKET (pocket), 0);
id = pocket->free_id++;
- g_assert (id != 0);
+ assert (id != 0);
i = pocket->n_entries++;
pocket->entries = g_renew (BseDataPocketEntry, pocket->entries, pocket->n_entries);
diff --git a/bse/bsedevice.cc b/bse/bsedevice.cc
index 116c6b4..0094501 100644
--- a/bse/bsedevice.cc
+++ b/bse/bsedevice.cc
@@ -492,7 +492,7 @@ BSE_BUILTIN_TYPE (BseDevice)
(GInstanceInitFunc) bse_device_init,
};
- g_assert (BSE_DEVICE_FLAGS_USHIFT < BSE_OBJECT_FLAGS_MAX_SHIFT);
+ assert (BSE_DEVICE_FLAGS_USHIFT < BSE_OBJECT_FLAGS_MAX_SHIFT);
return bse_type_register_abstract (BSE_TYPE_OBJECT,
"BseDevice",
diff --git a/bse/bseeditablesample.cc b/bse/bseeditablesample.cc
index 4e135f0..a1ff88e 100644
--- a/bse/bseeditablesample.cc
+++ b/bse/bseeditablesample.cc
@@ -45,7 +45,7 @@ BSE_BUILTIN_TYPE (BseEditableSample)
(GInstanceInitFunc) bse_editable_sample_init,
};
- g_assert (BSE_EDITABLE_SAMPLE_FLAGS_USHIFT < BSE_OBJECT_FLAGS_MAX_SHIFT);
+ assert (BSE_EDITABLE_SAMPLE_FLAGS_USHIFT < BSE_OBJECT_FLAGS_MAX_SHIFT);
return bse_type_register_static (BSE_TYPE_ITEM,
"BseEditableSample",
diff --git a/bse/bseengine.cc b/bse/bseengine.cc
index 81edc4e..2be7427 100644
--- a/bse/bseengine.cc
+++ b/bse/bseengine.cc
@@ -1368,10 +1368,10 @@ bse_engine_init (gboolean run_threaded)
assert_return (bse_engine_initialized == FALSE);
bse_engine_initialized = TRUE;
/* assert correct implmentation of accessor macros defined in bsedefs.hh */
- g_assert (&BSE_MODULE_GET_USER_DATA ((BseModule*) 42) == &((BseModule*) 42)->user_data);
- g_assert (&BSE_MODULE_GET_ISTREAMSP ((BseModule*) 42) == (void*) &((BseModule*) 42)->istreams);
- g_assert (&BSE_MODULE_GET_JSTREAMSP ((BseModule*) 42) == (void*) &((BseModule*) 42)->jstreams);
- g_assert (&BSE_MODULE_GET_OSTREAMSP ((BseModule*) 42) == (void*) &((BseModule*) 42)->ostreams);
+ assert (&BSE_MODULE_GET_USER_DATA ((BseModule*) 42) == &((BseModule*) 42)->user_data);
+ assert (&BSE_MODULE_GET_ISTREAMSP ((BseModule*) 42) == (void*) &((BseModule*) 42)->istreams);
+ assert (&BSE_MODULE_GET_JSTREAMSP ((BseModule*) 42) == (void*) &((BseModule*) 42)->jstreams);
+ assert (&BSE_MODULE_GET_OSTREAMSP ((BseModule*) 42) == (void*) &((BseModule*) 42)->ostreams);
/* first configure */
bse_engine_configure (50, 44100, 50);
/* then setup threading */
diff --git a/bse/bseenginemaster.cc b/bse/bseenginemaster.cc
index fb918f6..3754707 100644
--- a/bse/bseenginemaster.cc
+++ b/bse/bseenginemaster.cc
@@ -126,7 +126,7 @@ master_idisconnect_node (EngineNode *node,
guint ostream = node->inputs[istream].src_stream;
gboolean was_consumer;
- g_assert (ostream < ENGINE_NODE_N_OSTREAMS (src_node) &&
+ assert (ostream < ENGINE_NODE_N_OSTREAMS (src_node) &&
src_node->outputs[ostream].n_outputs > 0); /* these checks better pass */
node->inputs[istream].src_node = NULL;
@@ -154,7 +154,7 @@ master_jdisconnect_node (EngineNode *node,
guint i, ostream = node->jinputs[jstream][con].src_stream;
gboolean was_consumer;
- g_assert (ostream < ENGINE_NODE_N_OSTREAMS (src_node) &&
+ assert (ostream < ENGINE_NODE_N_OSTREAMS (src_node) &&
node->module.jstreams[jstream].jcount > 0 &&
src_node->outputs[ostream].n_outputs > 0); /* these checks better pass */
@@ -711,7 +711,7 @@ master_take_probes (EngineNode *node,
if (ptype == PROBE_SCHEDULED)
{
uint i;
- g_assert (tjob->probe.n_ostreams == ENGINE_NODE_N_OSTREAMS (node));
+ assert (tjob->probe.n_ostreams == ENGINE_NODE_N_OSTREAMS (node));
/* swap output buffers with probe buffers */
BseOStream *ostreams = node->module.ostreams;
node->module.ostreams = tjob->probe.ostreams;
@@ -873,7 +873,7 @@ master_process_flow (void)
assert_return (master_need_process == TRUE);
- g_assert (bse_fpu_okround () == TRUE);
+ assert (bse_fpu_okround () == TRUE);
if (master_schedule)
{
diff --git a/bse/bseengineschedule.cc b/bse/bseengineschedule.cc
index cfaa716..383dc31 100644
--- a/bse/bseengineschedule.cc
+++ b/bse/bseengineschedule.cc
@@ -369,8 +369,8 @@ _engine_schedule_consumer_node (EngineSchedule *schedule,
assert_return (ENGINE_NODE_IS_VIRTUAL (node) == FALSE);
subschedule_query_node (schedule, node, &query);
- g_assert (query.cycles == NULL); /* paranoid */
- g_assert (query.cycle_nodes == NULL); /* paranoid */
+ assert (query.cycles == NULL); /* paranoid */
+ assert (query.cycle_nodes == NULL); /* paranoid */
schedule_node (schedule, node, query.leaf_level);
}
@@ -406,7 +406,7 @@ determine_suspension_state (EngineNode *node,
{
gboolean seen_cycle = FALSE;
guint64 stamp;
- g_assert (node->in_suspend_call == FALSE);
+ assert (node->in_suspend_call == FALSE);
if (node->update_suspend)
{
node->in_suspend_call = TRUE;
@@ -467,13 +467,13 @@ merge_untagged_node_lists_uniq (SfiRing *ring1,
for (walk = ring2; walk; walk = sfi_ring_walk (walk, ring2))
{
EngineNode *node = (EngineNode*) walk->data;
- g_assert (node->sched_recurse_tag == FALSE);
+ assert (node->sched_recurse_tag == FALSE);
}
/* tag all nodes in ring1 first */
for (walk = ring1; walk; walk = sfi_ring_walk (walk, ring1))
{
EngineNode *node = (EngineNode*) walk->data;
- g_assert (node->sched_recurse_tag == FALSE); /* paranoid check */
+ assert (node->sched_recurse_tag == FALSE); /* paranoid check */
node->sched_recurse_tag = TRUE;
}
/* merge list with missing (untagged) nodes */
@@ -521,7 +521,7 @@ master_resolve_cycles (EngineQuery *query,
{
SfiRing *walk;
gboolean all_resolved = TRUE;
- g_assert (query->cycles != NULL); /* paranoid */
+ assert (query->cycles != NULL); /* paranoid */
walk = query->cycles;
while (walk)
{
@@ -529,8 +529,8 @@ master_resolve_cycles (EngineQuery *query,
EngineCycle *cycle = (EngineCycle*) walk->data;
if (resolve_cycle (cycle, node, &query->cycle_nodes))
{
- g_assert (cycle->last == NULL); /* paranoid */
- g_assert (cycle->nodes == NULL); /* paranoid */
+ assert (cycle->last == NULL); /* paranoid */
+ assert (cycle->nodes == NULL); /* paranoid */
sfi_delete_struct (EngineCycle, cycle);
query->cycles = sfi_ring_remove_node (query->cycles, walk);
}
@@ -539,7 +539,7 @@ master_resolve_cycles (EngineQuery *query,
walk = next;
}
if (all_resolved)
- g_assert (query->cycles == NULL); /* paranoid */
+ assert (query->cycles == NULL); /* paranoid */
return all_resolved;
}
@@ -562,7 +562,7 @@ query_merge_cycles (EngineQuery *query,
EngineNode *node)
{
SfiRing *walk;
- g_assert (child_query->cycles != NULL); /* paranoid */
+ assert (child_query->cycles != NULL); /* paranoid */
/* add node to all child cycles */
for (walk = child_query->cycles; walk; walk = sfi_ring_walk (walk, child_query->cycles))
{
@@ -654,18 +654,18 @@ subschedule_child (EngineSchedule *schedule,
query->leaf_level = MAX (query->leaf_level, child_query.leaf_level + 1);
if (!child_query.cycles)
{
- g_assert (child_query.cycle_nodes == NULL); /* paranoid */
+ assert (child_query.cycle_nodes == NULL); /* paranoid */
schedule_node (schedule, child, child_query.leaf_level);
}
else if (master_resolve_cycles (&child_query, child))
{
- g_assert (child == child_query.cycle_nodes->data); /* paranoid */
+ assert (child == child_query.cycle_nodes->data); /* paranoid */
schedule_cycle (schedule, child_query.cycle_nodes, child_query.leaf_level);
child_query.cycle_nodes = NULL;
}
else
query_merge_cycles (query, &child_query, node);
- g_assert (child_query.cycles == NULL && child_query.cycle_nodes == NULL); /* paranoid */
+ assert (child_query.cycles == NULL && child_query.cycle_nodes == NULL); /* paranoid */
}
}
diff --git a/bse/bseengineutils.cc b/bse/bseengineutils.cc
index 7a72a31..f4d6c02 100644
--- a/bse/bseengineutils.cc
+++ b/bse/bseengineutils.cc
@@ -67,7 +67,7 @@ void
bse_engine_free_ostreams (guint n_ostreams,
BseOStream *ostreams)
{
- g_assert (n_ostreams > 0);
+ assert (n_ostreams > 0);
/* bse_engine_block_size() may have changed since allocation */
g_free (ostreams);
}
@@ -413,7 +413,7 @@ engine_fetch_process_queue_trash_jobs_U (EngineTimedJob **trash_tjobs_head,
* during processing. to ensure this, we assert that no flow processing
* schedule is currently set.
*/
- g_assert (pqueue_schedule == NULL);
+ assert (pqueue_schedule == NULL);
pqueue_mutex.unlock();
}
else
@@ -511,7 +511,7 @@ _engine_push_processed_node (EngineNode *node)
assert_return (pqueue_n_nodes > 0);
assert_return (ENGINE_NODE_IS_SCHEDULED (node));
pqueue_mutex.lock();
- g_assert (pqueue_n_nodes > 0); /* paranoid */
+ assert (pqueue_n_nodes > 0); /* paranoid */
collect_user_jobs_L (node);
pqueue_n_nodes -= 1;
ENGINE_NODE_UNLOCK (node);
@@ -588,7 +588,7 @@ _engine_mnl_integrate (EngineNode *node)
master_node_list_tail = node;
if (!master_node_list_head)
master_node_list_head = master_node_list_tail;
- g_assert (node->mnl_next == NULL);
+ assert (node->mnl_next == NULL);
}
void
@@ -646,7 +646,7 @@ bse_engine_const_zeros (guint smaller_than_BSE_STREAM_MAX_VALUES)
{
static const float engine_const_zero_block[BSE_STREAM_MAX_VALUES + 16 /* SIMD alignment */] = { 0, };
/* this function is callable from any thread */
- g_assert (smaller_than_BSE_STREAM_MAX_VALUES <= BSE_STREAM_MAX_VALUES);
+ assert (smaller_than_BSE_STREAM_MAX_VALUES <= BSE_STREAM_MAX_VALUES);
return (float*) engine_const_zero_block;
}
@@ -714,7 +714,7 @@ const_values_insert (ConstValuesArray *array,
array->nodes = (float**) g_realloc (array->nodes, new_size);
array->nodes_used = (guint8*) g_realloc (array->nodes_used, new_size / sizeof (gfloat*));
array->n_nodes = 1;
- g_assert (index == 0);
+ assert (index == 0);
}
else
{
diff --git a/bse/bsegconfig.cc b/bse/bsegconfig.cc
index de0066b..e9551c7 100644
--- a/bse/bsegconfig.cc
+++ b/bse/bsegconfig.cc
@@ -89,7 +89,7 @@ expand_sub14 (char *gstr)
// UTF-8: "\xef\xbf\xb9\x1a\xef\xbf\xba{{...}}\xef\xbf\xbb";
const char *pattern = "\357\277\271\357\277\272\\{\\{([^{}]*)\\}\\}\357\277\273";
rc = regcomp (&preg, pattern, REG_EXTENDED); // FIXME: should be atomic
- g_assert (rc == 0 && preg.re_nsub);
+ assert (rc == 0 && preg.re_nsub);
// if non-static: regfree (&preg);
}
regmatch_t pm[2] = { { 0, }, };
diff --git a/bse/bseinstrumentinput.cc b/bse/bseinstrumentinput.cc
index 5b85440..c2589f7 100644
--- a/bse/bseinstrumentinput.cc
+++ b/bse/bseinstrumentinput.cc
@@ -103,7 +103,7 @@ bse_instrument_input_class_init (BseInstrumentInputClass *klass)
item_class->set_parent = bse_instrument_input_set_parent;
/* assert parent class introduced enough ports */
- g_assert (BSE_SUB_IPORT_N_PORTS >= 4);
+ assert (BSE_SUB_IPORT_N_PORTS >= 4);
/* override parent properties with NOP properties */
for (i = 0; i < BSE_SUB_IPORT_N_PORTS; i++)
{
@@ -115,13 +115,13 @@ bse_instrument_input_class_init (BseInstrumentInputClass *klass)
}
ochannel_id = bse_source_class_add_ochannel (source_class, "frequency", _("Frequency"), _("Note
Frequency"));
- g_assert (ochannel_id == BSE_INSTRUMENT_INPUT_OCHANNEL_FREQUENCY);
+ assert (ochannel_id == BSE_INSTRUMENT_INPUT_OCHANNEL_FREQUENCY);
ochannel_id = bse_source_class_add_ochannel (source_class, "gate", _("Gate"), _("High if the note is
currently being pressed"));
- g_assert (ochannel_id == BSE_INSTRUMENT_INPUT_OCHANNEL_GATE);
+ assert (ochannel_id == BSE_INSTRUMENT_INPUT_OCHANNEL_GATE);
ochannel_id = bse_source_class_add_ochannel (source_class, "velocity", _("Velocity"), _("Velocity of the
note press"));
- g_assert (ochannel_id == BSE_INSTRUMENT_INPUT_OCHANNEL_VELOCITY);
+ assert (ochannel_id == BSE_INSTRUMENT_INPUT_OCHANNEL_VELOCITY);
ochannel_id = bse_source_class_add_ochannel (source_class, "aftertouch", _("Aftertouch"), _("Velocity
while the note is pressed"));
- g_assert (ochannel_id == BSE_INSTRUMENT_INPUT_OCHANNEL_AFTERTOUCH);
+ assert (ochannel_id == BSE_INSTRUMENT_INPUT_OCHANNEL_AFTERTOUCH);
}
BSE_BUILTIN_TYPE (BseInstrumentInput)
diff --git a/bse/bseinstrumentoutput.cc b/bse/bseinstrumentoutput.cc
index b941bf8..6820784 100644
--- a/bse/bseinstrumentoutput.cc
+++ b/bse/bseinstrumentoutput.cc
@@ -103,7 +103,7 @@ bse_instrument_output_class_init (BseInstrumentOutputClass *klass)
item_class->set_parent = bse_instrument_output_set_parent;
/* assert parent class introduced enough ports */
- g_assert (BSE_SUB_OPORT_N_PORTS >= 4);
+ assert (BSE_SUB_OPORT_N_PORTS >= 4);
/* override parent properties with NOP properties */
for (i = 0; i < BSE_SUB_OPORT_N_PORTS; i++)
{
@@ -115,13 +115,13 @@ bse_instrument_output_class_init (BseInstrumentOutputClass *klass)
}
ichannel_id = bse_source_class_add_ichannel (source_class, "left-audio", _("Left Audio"), _("Left Channel
Output"));
- g_assert (ichannel_id == BSE_INSTRUMENT_OUTPUT_ICHANNEL_LEFT);
+ assert (ichannel_id == BSE_INSTRUMENT_OUTPUT_ICHANNEL_LEFT);
ichannel_id = bse_source_class_add_ichannel (source_class, "right-audio", _("Right Audio"), _("Right
Channel Output"));
- g_assert (ichannel_id == BSE_INSTRUMENT_OUTPUT_ICHANNEL_RIGHT);
+ assert (ichannel_id == BSE_INSTRUMENT_OUTPUT_ICHANNEL_RIGHT);
ichannel_id = bse_source_class_add_ichannel (source_class, "unused", _("Unused"), NULL);
- g_assert (ichannel_id == BSE_INSTRUMENT_OUTPUT_ICHANNEL_UNUSED);
+ assert (ichannel_id == BSE_INSTRUMENT_OUTPUT_ICHANNEL_UNUSED);
ichannel_id = bse_source_class_add_ichannel (source_class, "synth-done", _("Synth Done"), _("High
indicates the instrument is done synthesizing"));
- g_assert (ichannel_id == BSE_INSTRUMENT_OUTPUT_ICHANNEL_DONE);
+ assert (ichannel_id == BSE_INSTRUMENT_OUTPUT_ICHANNEL_DONE);
}
BSE_BUILTIN_TYPE (BseInstrumentOutput)
diff --git a/bse/bseitem.cc b/bse/bseitem.cc
index 34e984c..00c195c 100644
--- a/bse/bseitem.cc
+++ b/bse/bseitem.cc
@@ -66,7 +66,7 @@ BSE_BUILTIN_TYPE (BseItem)
(GInstanceInitFunc) bse_item_init,
};
- g_assert (BSE_ITEM_FLAGS_USHIFT < BSE_OBJECT_FLAGS_MAX_SHIFT);
+ assert (BSE_ITEM_FLAGS_USHIFT < BSE_OBJECT_FLAGS_MAX_SHIFT);
return bse_type_register_abstract (BSE_TYPE_OBJECT,
"BseItem",
diff --git a/bse/bseladspamodule.cc b/bse/bseladspamodule.cc
index 1ff2640..19dc648 100644
--- a/bse/bseladspamodule.cc
+++ b/bse/bseladspamodule.cc
@@ -75,7 +75,7 @@ ladspa_derived_class_init (BseLadspaModuleClass *klass,
derived_parent_class = g_type_class_peek_parent (klass);
- g_assert (class_data != NULL);
+ assert (class_data != NULL);
klass->bli = (BseLadspaInfo*) class_data;
gobject_class->finalize = ladspa_derived_finalize;
@@ -97,7 +97,7 @@ bse_ladspa_module_derived_type_info (GType type,
BseLadspaInfo *bli,
GTypeInfo *type_info)
{
- g_assert (bli != NULL);
+ assert (bli != NULL);
type_info->class_size = sizeof (BseLadspaModuleClass);
type_info->class_init = (GClassInitFunc) ladspa_derived_class_init;
type_info->class_finalize = (GClassFinalizeFunc) ladspa_derived_class_finalize;
@@ -115,7 +115,7 @@ bse_ladspa_module_class_init_from_info (BseLadspaModuleClass *ladspa_module_clas
BseLadspaInfo *bli = ladspa_module_class->bli;
uint ochannel, ichannel, i;
- g_assert (ladspa_module_class->bli != NULL &&
+ assert (ladspa_module_class->bli != NULL &&
gobject_class->set_property == NULL &&
gobject_class->get_property == NULL);
diff --git a/bse/bseloader-aiff.cc b/bse/bseloader-aiff.cc
index 6b89fd4..30cfadb 100644
--- a/bse/bseloader-aiff.cc
+++ b/bse/bseloader-aiff.cc
@@ -542,7 +542,7 @@ _gsl_init_loader_aiff (void)
};
static gboolean initialized = FALSE;
- g_assert (initialized == FALSE);
+ assert (initialized == FALSE);
initialized = TRUE;
bse_loader_register (&loader);
diff --git a/bse/bseloader-bsewave.cc b/bse/bseloader-bsewave.cc
index 628e0f7..e32211d 100644
--- a/bse/bseloader-bsewave.cc
+++ b/bse/bseloader-bsewave.cc
@@ -145,7 +145,7 @@ bsewave_load_file_info (void *data,
{
const char *p = strrchr (_file_name, G_DIR_SEPARATOR);
- g_assert (p != NULL);
+ assert (p != NULL);
cwd = g_strndup (_file_name, p - _file_name + 1);
file_name = g_strdup (_file_name);
}
@@ -863,7 +863,7 @@ _gsl_init_loader_gslwave (void)
};
static gboolean initialized = FALSE;
- g_assert (initialized == FALSE);
+ assert (initialized == FALSE);
initialized = TRUE;
bse_loader_register (&loader);
diff --git a/bse/bseloader-flac.cc b/bse/bseloader-flac.cc
index 257a302..7b4f228 100644
--- a/bse/bseloader-flac.cc
+++ b/bse/bseloader-flac.cc
@@ -182,7 +182,7 @@ bse_init_loader_flac (void)
};
static gboolean initialized = FALSE;
- g_assert (initialized == FALSE);
+ assert (initialized == FALSE);
initialized = TRUE;
bse_loader_register (&loader);
diff --git a/bse/bseloader-guspatch.cc b/bse/bseloader-guspatch.cc
index a311d8d..72e29d8 100644
--- a/bse/bseloader-guspatch.cc
+++ b/bse/bseloader-guspatch.cc
@@ -625,7 +625,7 @@ bse_init_loader_gus_patch (void)
};
static gboolean initialized = FALSE;
- g_assert (initialized == FALSE);
+ assert (initialized == FALSE);
initialized = TRUE;
bse_loader_register (&loader);
diff --git a/bse/bseloader-mad.cc b/bse/bseloader-mad.cc
index 22f3354..48803bd 100644
--- a/bse/bseloader-mad.cc
+++ b/bse/bseloader-mad.cc
@@ -195,7 +195,7 @@ _gsl_init_loader_mad (void)
};
static gboolean initialized = FALSE;
- g_assert (initialized == FALSE);
+ assert (initialized == FALSE);
initialized = TRUE;
if (BSE_HAVE_LIBMAD)
diff --git a/bse/bseloader-oggvorbis.cc b/bse/bseloader-oggvorbis.cc
index c69284d..8d018aa 100644
--- a/bse/bseloader-oggvorbis.cc
+++ b/bse/bseloader-oggvorbis.cc
@@ -158,7 +158,7 @@ _gsl_init_loader_oggvorbis (void)
};
static gboolean initialized = FALSE;
- g_assert (initialized == FALSE);
+ assert (initialized == FALSE);
initialized = TRUE;
bse_loader_register (&loader);
diff --git a/bse/bseloader-wav.cc b/bse/bseloader-wav.cc
index efe19c9..590fdf0 100644
--- a/bse/bseloader-wav.cc
+++ b/bse/bseloader-wav.cc
@@ -41,7 +41,7 @@ wav_read_header (int fd,
/* read header contents */
n_bytes = 4 + 4 + 4;
- g_assert (n_bytes == sizeof (*header));
+ assert (n_bytes == sizeof (*header));
if (read (fd, header, n_bytes) != n_bytes)
{
LDEBUG ("failed to read WavHeader: %s", g_strerror (errno));
@@ -94,7 +94,7 @@ wav_read_fmt_header (int fd,
/* read header contents */
n_bytes = 4 + 4 + 2 + 2 + 4 + 4 + 2 + 2;
- g_assert (n_bytes == sizeof (*header));
+ assert (n_bytes == sizeof (*header));
if (read (fd, header, n_bytes) != n_bytes)
{
LDEBUG ("failed to read FmtHeader");
@@ -196,7 +196,7 @@ wav_read_data_header (int fd,
/* read header contents */
n_bytes = 4 + 4;
- g_assert (n_bytes == sizeof (*header));
+ assert (n_bytes == sizeof (*header));
if (read (fd, header, n_bytes) != n_bytes)
{
LDEBUG ("failed to read DataHeader");
@@ -456,7 +456,7 @@ _gsl_init_loader_wav (void)
};
static gboolean initialized = FALSE;
- g_assert (initialized == FALSE);
+ assert (initialized == FALSE);
initialized = TRUE;
bse_loader_register (&loader);
diff --git a/bse/bsemain.cc b/bse/bsemain.cc
index 37a47e3..34778ba 100644
--- a/bse/bsemain.cc
+++ b/bse/bsemain.cc
@@ -97,7 +97,7 @@ bse_init_intern()
// paranoid assertions
if (bse_initialization_stage != 0 || ++bse_initialization_stage != 1)
g_error ("%s() may only be called once", "bse_init_inprocess");
- g_assert (G_BYTE_ORDER == G_LITTLE_ENDIAN || G_BYTE_ORDER == G_BIG_ENDIAN);
+ assert (G_BYTE_ORDER == G_LITTLE_ENDIAN || G_BYTE_ORDER == G_BIG_ENDIAN);
// main loop
bse_main_context = g_main_context_new ();
diff --git a/bse/bsemidicontroller.cc b/bse/bsemidicontroller.cc
index b52039c..1f7a7ad 100644
--- a/bse/bsemidicontroller.cc
+++ b/bse/bsemidicontroller.cc
@@ -120,13 +120,13 @@ bse_midi_controller_class_init (BseMidiControllerClass *klass)
SFI_PARAM_STANDARD));
ochannel_id = bse_source_class_add_ochannel (source_class, "ctrl-out1", _("Ctrl Out1"), _("MIDI Signal
1"));
- g_assert (ochannel_id == BSE_MIDI_CONTROLLER_OCHANNEL_CONTROL1);
+ assert (ochannel_id == BSE_MIDI_CONTROLLER_OCHANNEL_CONTROL1);
ochannel_id = bse_source_class_add_ochannel (source_class, "ctrl-out2", _("Ctrl Out2"), _("MIDI Signal
2"));
- g_assert (ochannel_id == BSE_MIDI_CONTROLLER_OCHANNEL_CONTROL2);
+ assert (ochannel_id == BSE_MIDI_CONTROLLER_OCHANNEL_CONTROL2);
ochannel_id = bse_source_class_add_ochannel (source_class, "ctrl-out3", _("Ctrl Out3"), _("MIDI Signal
3"));
- g_assert (ochannel_id == BSE_MIDI_CONTROLLER_OCHANNEL_CONTROL3);
+ assert (ochannel_id == BSE_MIDI_CONTROLLER_OCHANNEL_CONTROL3);
ochannel_id = bse_source_class_add_ochannel (source_class, "ctrl-out4", _("Ctrl Out4"), _("MIDI Signal
4"));
- g_assert (ochannel_id == BSE_MIDI_CONTROLLER_OCHANNEL_CONTROL4);
+ assert (ochannel_id == BSE_MIDI_CONTROLLER_OCHANNEL_CONTROL4);
}
static void
diff --git a/bse/bsemididecoder.cc b/bse/bsemididecoder.cc
index 5a8dcfc..40ec567 100644
--- a/bse/bsemididecoder.cc
+++ b/bse/bsemididecoder.cc
@@ -92,7 +92,7 @@ midi_decoder_advance_state (BseMidiDecoder *self)
self->delta_time = 0;
self->event_type = BseMidiEventType (0);
/* keep running_mode and zchannel */
- g_assert (self->left_bytes == 0);
+ assert (self->left_bytes == 0);
if (self->n_bytes)
g_warning ("leaking %d bytes of midi data", self->n_bytes);
self->n_bytes = 0;
diff --git a/bse/bsemididevice-null.cc b/bse/bsemididevice-null.cc
index 5a900c3..3d711b0 100644
--- a/bse/bsemididevice-null.cc
+++ b/bse/bsemididevice-null.cc
@@ -46,7 +46,7 @@ bse_midi_device_null_close (BseDevice *device)
NULLHandle *null = (NULLHandle*) BSE_MIDI_DEVICE (device)->handle;
BseMidiHandle *handle = &null->handle;
BSE_MIDI_DEVICE (device)->handle = NULL;
- g_assert (handle->running_thread == FALSE);
+ assert (handle->running_thread == FALSE);
/* midi_handle_abort_wait (handle); */
g_free (null);
}
diff --git a/bse/bsemididevice-oss.cc b/bse/bsemididevice-oss.cc
index ccff55e..221a2e7 100644
--- a/bse/bsemididevice-oss.cc
+++ b/bse/bsemididevice-oss.cc
@@ -177,7 +177,7 @@ bse_midi_device_oss_close (BseDevice *device)
OSSHandle *oss = (OSSHandle*) BSE_MIDI_DEVICE (device)->handle;
BseMidiHandle *handle = &oss->handle;
BSE_MIDI_DEVICE (device)->handle = NULL;
- g_assert (handle->running_thread == FALSE);
+ assert (handle->running_thread == FALSE);
/* midi_handle_abort_wait (handle); */
Bse::Sequencer::instance().remove_io_watch (oss_midi_io_handler, oss);
(void) close (oss->fd);
@@ -205,7 +205,7 @@ oss_midi_io_handler (void *data, /* Sequencer Thread */
gssize l;
/* this should spawn its own thread someday */
- g_assert (handle->running_thread == FALSE);
+ assert (handle->running_thread == FALSE);
systime = sfi_time_system ();
do
diff --git a/bse/bsemidiinput.cc b/bse/bsemidiinput.cc
index e0b3cea..eabf37f 100644
--- a/bse/bsemidiinput.cc
+++ b/bse/bsemidiinput.cc
@@ -91,13 +91,13 @@ bse_midi_input_class_init (BseMidiInputClass *klass)
SFI_PARAM_GUI SFI_PARAM_STORAGE ":scale:skip-default"));
ochannel_id = bse_source_class_add_ochannel (source_class, "frequency", _("Frequency"), _("Note
Frequency"));
- g_assert (ochannel_id == BSE_MIDI_INPUT_OCHANNEL_FREQUENCY);
+ assert (ochannel_id == BSE_MIDI_INPUT_OCHANNEL_FREQUENCY);
ochannel_id = bse_source_class_add_ochannel (source_class, "gate", _("Gate"), _("High if the note is
currently being pressed"));
- g_assert (ochannel_id == BSE_MIDI_INPUT_OCHANNEL_GATE);
+ assert (ochannel_id == BSE_MIDI_INPUT_OCHANNEL_GATE);
ochannel_id = bse_source_class_add_ochannel (source_class, "velocity", _("Velocity"), _("Velocity of the
note press"));
- g_assert (ochannel_id == BSE_MIDI_INPUT_OCHANNEL_VELOCITY);
+ assert (ochannel_id == BSE_MIDI_INPUT_OCHANNEL_VELOCITY);
ochannel_id = bse_source_class_add_ochannel (source_class, "aftertouch", _("Aftertouch"), _("Velocity
while the note is pressed"));
- g_assert (ochannel_id == BSE_MIDI_INPUT_OCHANNEL_AFTERTOUCH);
+ assert (ochannel_id == BSE_MIDI_INPUT_OCHANNEL_AFTERTOUCH);
}
static void
diff --git a/bse/bsemidireceiver.cc b/bse/bsemidireceiver.cc
index 9090f0e..ba1813b 100644
--- a/bse/bsemidireceiver.cc
+++ b/bse/bsemidireceiver.cc
@@ -305,7 +305,7 @@ public:
}
~MidiReceiver()
{
- g_assert (ref_count == 0);
+ assert (ref_count == 0);
for (Channels::iterator it = midi_channels.begin(); it != midi_channels.end(); it++)
delete *it;
while (events)
@@ -743,7 +743,7 @@ change_voice_input_L (VoiceInput *vinput,
assert_return (vinput->iter == vinput->table->end());
vinput->next = (*vinput->table)[freq_value];
vinput->iter = vinput->table->find (freq_value);
- g_assert (vinput->iter != vinput->table->end());
+ assert (vinput->iter != vinput->table->end());
vinput->iter->second = vinput;
}
vinput->queue_state = VSTATE_BUSY;
@@ -787,7 +787,7 @@ voice_input_module_free_U (gpointer data,
const BseModuleClass *klass)
{
VoiceInput *vinput = (VoiceInput*) data;
- g_assert (vinput->next == NULL);
+ assert (vinput->next == NULL);
delete vinput;
}
diff --git a/bse/bsemidivoice.cc b/bse/bsemidivoice.cc
index d2eb110..373dc4d 100644
--- a/bse/bsemidivoice.cc
+++ b/bse/bsemidivoice.cc
@@ -92,13 +92,13 @@ bse_midi_voice_input_class_init (BseMidiVoiceInputClass *klass)
source_class->context_dismiss = bse_midi_voice_input_context_dismiss;
channel_id = bse_source_class_add_ochannel (source_class, "freq-out", _("Freq Out"), NULL);
- g_assert (channel_id == BSE_MIDI_VOICE_INPUT_OCHANNEL_FREQUENCY);
+ assert (channel_id == BSE_MIDI_VOICE_INPUT_OCHANNEL_FREQUENCY);
channel_id = bse_source_class_add_ochannel (source_class, "gate-out", _("Gate Out"), NULL);
- g_assert (channel_id == BSE_MIDI_VOICE_INPUT_OCHANNEL_GATE);
+ assert (channel_id == BSE_MIDI_VOICE_INPUT_OCHANNEL_GATE);
channel_id = bse_source_class_add_ochannel (source_class, "velocity-out", _("Velocity Out"), NULL);
- g_assert (channel_id == BSE_MIDI_VOICE_INPUT_OCHANNEL_VELOCITY);
+ assert (channel_id == BSE_MIDI_VOICE_INPUT_OCHANNEL_VELOCITY);
channel_id = bse_source_class_add_ochannel (source_class, "aftertouch-out", _("Aftertouch Out"), NULL);
- g_assert (channel_id == BSE_MIDI_VOICE_INPUT_OCHANNEL_AFTERTOUCH);
+ assert (channel_id == BSE_MIDI_VOICE_INPUT_OCHANNEL_AFTERTOUCH);
}
static void
@@ -116,17 +116,17 @@ bse_midi_voice_switch_class_init (BseMidiVoiceSwitchClass *klass)
source_class->context_dismiss = bse_midi_voice_switch_context_dismiss;
channel_id = bse_source_class_add_ichannel (source_class, "left-in", _("Left In"), NULL);
- g_assert (channel_id == BSE_MIDI_VOICE_SWITCH_ICHANNEL_LEFT);
+ assert (channel_id == BSE_MIDI_VOICE_SWITCH_ICHANNEL_LEFT);
channel_id = bse_source_class_add_ichannel (source_class, "right-in", _("Right In"), NULL);
- g_assert (channel_id == BSE_MIDI_VOICE_SWITCH_ICHANNEL_RIGHT);
+ assert (channel_id == BSE_MIDI_VOICE_SWITCH_ICHANNEL_RIGHT);
channel_id = bse_source_class_add_ichannel (source_class, "disconnect-in", _("Disconnect In"), NULL);
- g_assert (channel_id == BSE_MIDI_VOICE_SWITCH_ICHANNEL_DISCONNECT);
+ assert (channel_id == BSE_MIDI_VOICE_SWITCH_ICHANNEL_DISCONNECT);
channel_id = bse_source_class_add_ochannel (source_class, "left-out", _("Left Out"), NULL);
- g_assert (channel_id == BSE_MIDI_VOICE_SWITCH_ICHANNEL_LEFT);
+ assert (channel_id == BSE_MIDI_VOICE_SWITCH_ICHANNEL_LEFT);
channel_id = bse_source_class_add_ochannel (source_class, "right-out", _("Right Out"), NULL);
- g_assert (channel_id == BSE_MIDI_VOICE_SWITCH_ICHANNEL_RIGHT);
+ assert (channel_id == BSE_MIDI_VOICE_SWITCH_ICHANNEL_RIGHT);
channel_id = bse_source_class_add_ochannel (source_class, "disconnect-out", _("Disconnect Out"), NULL);
- g_assert (channel_id == BSE_MIDI_VOICE_SWITCH_ICHANNEL_DISCONNECT);
+ assert (channel_id == BSE_MIDI_VOICE_SWITCH_ICHANNEL_DISCONNECT);
}
static void
diff --git a/bse/bseobject.cc b/bse/bseobject.cc
index 27df7a2..d561f78 100644
--- a/bse/bseobject.cc
+++ b/bse/bseobject.cc
@@ -453,7 +453,7 @@ bse_object_lock (gpointer _object)
assert_return (BSE_IS_OBJECT (object));
assert_return (gobject->ref_count > 0);
- g_assert (object->lock_count < 65535); // if this breaks, we need to fix the guint16
+ assert (object->lock_count < 65535); // if this breaks, we need to fix the guint16
if (!object->lock_count)
{
diff --git a/bse/bseparasite.cc b/bse/bseparasite.cc
index e664fb7..2b5d1c8 100644
--- a/bse/bseparasite.cc
+++ b/bse/bseparasite.cc
@@ -76,7 +76,7 @@ parasite_node_cmp (gconstpointer bsn1,
static void
parasite_init (BseItem *item)
{
- g_assert (item->parasite == NULL);
+ assert (item->parasite == NULL);
item->parasite = g_new0 (BseParasite, 1);
item->parasite->nodes = g_bsearch_array_create (&bconfig_nodes);
item->parasite->crefs = g_bsearch_array_create (&bconfig_crefs);
@@ -355,7 +355,7 @@ bse_item_delete_parasites (BseItem *item)
g_bsearch_array_get_n_nodes (item->parasite->nodes)
- 1);
bse_item_set_parasite (item, node->path, NULL);
}
- g_assert (g_bsearch_array_get_n_nodes (item->parasite->crefs) == 0);
+ assert (g_bsearch_array_get_n_nodes (item->parasite->crefs) == 0);
g_bsearch_array_free (item->parasite->nodes, &bconfig_nodes);
g_bsearch_array_free (item->parasite->crefs, &bconfig_crefs);
g_free (item->parasite);
diff --git a/bse/bsepart.cc b/bse/bsepart.cc
index d717402..89d2776 100644
--- a/bse/bsepart.cc
+++ b/bse/bsepart.cc
@@ -276,7 +276,7 @@ bse_part_alloc_id (BsePart *self,
{
guint i = self->last_id - 1;
- g_assert (self->ids[i] >= BSE_PART_INVAL_TICK_FLAG);
+ assert (self->ids[i] >= BSE_PART_INVAL_TICK_FLAG);
self->last_id = self->ids[i] - BSE_PART_INVAL_TICK_FLAG;
id = i + 1;
@@ -1664,7 +1664,7 @@ bse_part_controls_lookup_ge (BsePartControls *self,
{
guint ix = 1 + g_bsearch_array_get_index (self->bsa, &controls_bsc, node);
node = (BsePartTickNode*) g_bsearch_array_get_nth (self->bsa, &controls_bsc, ix); /* returns NULL for
i >= n_nodes */
- g_assert (!node || node->tick >= tick);
+ assert (!node || node->tick >= tick);
}
return node;
}
@@ -1679,7 +1679,7 @@ bse_part_controls_lookup_le (BsePartControls *self,
if (node && node->tick > tick) /* adjust smaller ticks */
{
node = g_bsearch_array_get_index (self->bsa, &controls_bsc, node) > 0 ? node - 1 : NULL;
- g_assert (!node || node->tick <= tick);
+ assert (!node || node->tick <= tick);
}
return node;
}
@@ -1876,7 +1876,7 @@ bse_part_note_channel_lookup_le (BsePartNoteChannel *self,
if (note && note->tick > tick) /* adjust greater ticks */
{
note = g_bsearch_array_get_index (self->bsa, ¬e_channel_bsc, note) > 0 ? note - 1 : NULL;
- g_assert (!note || note->tick <= tick);
+ assert (!note || note->tick <= tick);
}
return note;
}
@@ -1899,7 +1899,7 @@ bse_part_note_channel_lookup_ge (BsePartNoteChannel *self,
{
guint ix = 1 + g_bsearch_array_get_index (self->bsa, ¬e_channel_bsc, note);
note = (BsePartEventNote*) g_bsearch_array_get_nth (self->bsa, ¬e_channel_bsc, ix); /* returns NULL
for i >= n_nodes */
- g_assert (!note || note->tick >= tick);
+ assert (!note || note->tick >= tick);
}
return note;
}
@@ -1933,7 +1933,7 @@ part_note_channel_check_crossing (BsePartNoteChannel *self,
BsePartEventNote key, *note;
key.tick = note_tick;
note = (BsePartEventNote*) g_bsearch_array_lookup (self->bsa, ¬e_channel_bsc, &key);
- g_assert (note);
+ assert (note);
return note->tick + note->duration > tick_mark;
}
@@ -1960,7 +1960,7 @@ part_note_channel_crossings_remove (guint *crossings,
crossings[i] = crossings[n_crossings];
break;
}
- g_assert (i <= n_crossings); /* must have found one */
+ assert (i <= n_crossings); /* must have found one */
n_crossings--;
if (n_crossings)
crossings[0] = n_crossings;
@@ -1983,7 +1983,7 @@ bse_part_note_channel_insert (BsePartNoteChannel *self, BsePartEventNote key)
self->bsa = g_bsearch_array_insert (self->bsa, ¬e_channel_bsc, &key);
BSE_SEQUENCER_UNLOCK ();
note = (BsePartEventNote*) g_bsearch_array_lookup (self->bsa, ¬e_channel_bsc, &key);
- g_assert (note->crossings == NULL && note->id == key.id);
+ assert (note->crossings == NULL && note->id == key.id);
ix = g_bsearch_array_get_index (self->bsa, ¬e_channel_bsc, note);
/* copy predecessor crossings */
if (ix > 0)
diff --git a/bse/bsepcminput.cc b/bse/bsepcminput.cc
index 029bcb4..3081ed0 100644
--- a/bse/bsepcminput.cc
+++ b/bse/bsepcminput.cc
@@ -110,9 +110,9 @@ bse_pcm_input_class_init (BsePcmInputClass *klass)
1, SFI_PARAM_GUI ":dial"));
ochannel_id = bse_source_class_add_ochannel (source_class, "left-audio-out", _("Left Audio Out"), _("Left
channel output"));
- g_assert (ochannel_id == BSE_PCM_INPUT_OCHANNEL_LEFT);
+ assert (ochannel_id == BSE_PCM_INPUT_OCHANNEL_LEFT);
ochannel_id = bse_source_class_add_ochannel (source_class, "right-audio-out", _("Right Audio Out"),
_("Right channel output"));
- g_assert (ochannel_id == BSE_PCM_INPUT_OCHANNEL_RIGHT);
+ assert (ochannel_id == BSE_PCM_INPUT_OCHANNEL_RIGHT);
}
static void
diff --git a/bse/bsepcmoutput.cc b/bse/bsepcmoutput.cc
index 5d81ce7..47fe26d 100644
--- a/bse/bsepcmoutput.cc
+++ b/bse/bsepcmoutput.cc
@@ -110,9 +110,9 @@ bse_pcm_output_class_init (BsePcmOutputClass *klass)
1, SFI_PARAM_GUI ":dial"));
ichannel_id = bse_source_class_add_ichannel (source_class, "left-audio-in", _("Left Audio In"), _("Left
channel input"));
- g_assert (ichannel_id == BSE_PCM_OUTPUT_ICHANNEL_LEFT);
+ assert (ichannel_id == BSE_PCM_OUTPUT_ICHANNEL_LEFT);
ichannel_id = bse_source_class_add_ichannel (source_class, "right-audio-in", _("Right Audio In"), _("Right
channel Input"));
- g_assert (ichannel_id == BSE_PCM_OUTPUT_ICHANNEL_RIGHT);
+ assert (ichannel_id == BSE_PCM_OUTPUT_ICHANNEL_RIGHT);
}
static void
diff --git a/bse/bseplugin.cc b/bse/bseplugin.cc
index 4ac5fc0..9115936 100644
--- a/bse/bseplugin.cc
+++ b/bse/bseplugin.cc
@@ -193,7 +193,7 @@ static BsePlugin *startup_plugin = NULL;
void
bse_plugin_make_resident()
{
- g_assert (startup_plugin != NULL);
+ assert (startup_plugin != NULL);
startup_plugin->resident_types = TRUE;
}
diff --git a/bse/bseprobe.cc b/bse/bseprobe.cc
index 2452e25..265c3f1 100644
--- a/bse/bseprobe.cc
+++ b/bse/bseprobe.cc
@@ -82,7 +82,7 @@ class ProbeQueue {
const gfloat *oblock,
bool connected)
{
- g_assert (n <= block_size - n_computed);
+ assert (n <= block_size - n_computed);
/* store samples, possibly for fft */
if (requests.samples || requests.fft)
{
@@ -297,7 +297,7 @@ public:
probes (_probes), block_size (_block_size),
first_stamp (0), n_computed (0), raw_floats (NULL)
{
- g_assert (block_size > 0);
+ assert (block_size > 0);
memset (&requests, 0, sizeof (requests));
reset_probe_state();
}
@@ -365,7 +365,7 @@ private:
std::pair<ProbeQueueSet::iterator,bool> result;
result = channel_sets[channel].insert (new ProbeQueue (*this, block_size));
it = result.first;
- g_assert (result.second == true);
+ assert (result.second == true);
}
return *it;
}
@@ -382,7 +382,7 @@ public:
{}
~SourceProbes ()
{
- g_assert (queued_jobs == 0);
+ assert (queued_jobs == 0);
reset_omodules();
for (uint j = 0; j < channel_sets.size(); j++)
{
@@ -409,7 +409,7 @@ private:
{}
~ProbeData()
{
- g_assert (ostreams == NULL);
+ assert (ostreams == NULL);
}
RAPICORN_CLASS_NON_COPYABLE (ProbeData);
};
@@ -420,14 +420,14 @@ private:
guint n_ostreams, /* ENGINE_NODE_N_OSTREAMS() */
BseOStream **ostreams_p)
{
- g_assert (pdata.n_pending > 0);
- g_assert (n_ostreams == channel_sets.size());
+ assert (pdata.n_pending > 0);
+ assert (n_ostreams == channel_sets.size());
/* preprocess data from multiple modules */
if (!pdata.ostreams) /* first module */
{
/* upon first block, "steal" ostreams */
- g_assert (pdata.ostreams == NULL);
- g_assert (pdata.debug_stamp == 0);
+ assert (pdata.ostreams == NULL);
+ assert (pdata.debug_stamp == 0);
pdata.ostreams = *ostreams_p;
*ostreams_p = NULL;
pdata.debug_n_values = n_values;
@@ -436,8 +436,8 @@ private:
else /* successive modules */
{
/* add up all successive blocks */
- g_assert (pdata.debug_stamp == tick_stamp);
- g_assert (pdata.debug_n_values == n_values);
+ assert (pdata.debug_stamp == tick_stamp);
+ assert (pdata.debug_n_values == n_values);
BseOStream *ostreams = *ostreams_p;
for (uint j = 0; j < n_ostreams; j++)
if (ostreams[j].connected && channel_sets[j].size() > 0)
@@ -483,9 +483,9 @@ private:
{
ProbeData *pdata = reinterpret_cast<ProbeData*> (data);
SourceProbes *probes = peek_from_source (pdata->source);
- g_assert (probes != NULL);
- g_assert (probes->queued_jobs > 0);
- g_assert (pdata->n_pending > 0);
+ assert (probes != NULL);
+ assert (probes->queued_jobs > 0);
+ assert (pdata->n_pending > 0);
probes->handle_probe (*pdata, n_values, tick_stamp, n_ostreams, ostreams_p);
if (!pdata->n_pending)
{
@@ -742,7 +742,7 @@ bse_source_probes_modules_changed (BseSource *source)
void
bse_source_class_add_probe_signals (BseSourceClass *klass)
{
- g_assert (bse_source_signal_probes == 0);
+ assert (bse_source_signal_probes == 0);
BseObjectClass *object_class = BSE_OBJECT_CLASS (klass);
bse_source_signal_probes = bse_object_class_add_signal (object_class, "probes", G_TYPE_NONE, 1,
BSE_TYPE_PROBE_SEQ);
}
diff --git a/bse/bseprocedure.cc b/bse/bseprocedure.cc
index 036efad..9c7f8ab 100644
--- a/bse/bseprocedure.cc
+++ b/bse/bseprocedure.cc
@@ -675,7 +675,7 @@ procedure_class_unref (BseProcedureClass *proc)
if (!proc->cache_stamp)
{
// g_printerr ("cache-procedure: %s\n", BSE_PROCEDURE_NAME (proc));
- g_assert (proc->cache_next == NULL);
+ assert (proc->cache_next == NULL);
proc->cache_stamp = 2; /* 'recent' stamp */
proc->cache_next = proc_cache;
proc_cache = proc;
diff --git a/bse/bseresampler.hh b/bse/bseresampler.hh
index 41e0135..516e4e3 100644
--- a/bse/bseresampler.hh
+++ b/bse/bseresampler.hh
@@ -109,7 +109,7 @@ protected:
taps[i] = d[i] * scaling;
Resampler2 *filter = new Filter (taps);
- g_assert (order == filter->order());
+ assert (order == filter->order());
return filter;
}
/* creates the actual implementation; specifying USE_SSE=true will use
diff --git a/bse/bseresamplerimpl.hh b/bse/bseresamplerimpl.hh
index 892c30b..12f2d12 100644
--- a/bse/bseresamplerimpl.hh
+++ b/bse/bseresamplerimpl.hh
@@ -289,7 +289,7 @@ public:
history (2 * ORDER),
sse_taps (fir_compute_sse_taps (taps))
{
- g_assert ((ORDER & 1) == 0); /* even order filter */
+ assert ((ORDER & 1) == 0); /* even order filter */
}
/**
* The function process_block() takes a block of input samples and produces a
@@ -428,7 +428,7 @@ public:
history_odd (2 * ORDER),
sse_taps (fir_compute_sse_taps (taps))
{
- g_assert ((ORDER & 1) == 0); /* even order filter */
+ assert ((ORDER & 1) == 0); /* even order filter */
}
/**
* The function process_block() takes a block of input samples and produces
@@ -439,7 +439,7 @@ public:
guint n_input_samples,
float *output)
{
- g_assert ((n_input_samples & 1) == 0);
+ assert ((n_input_samples & 1) == 0);
const uint BLOCKSIZE = 1024;
diff --git a/bse/bsesequencer.cc b/bse/bsesequencer.cc
index 71b7e7d..c55fdbc 100644
--- a/bse/bsesequencer.cc
+++ b/bse/bsesequencer.cc
@@ -49,7 +49,7 @@ public:
fill_pfds (guint n_pfds,
GPollFD *pfds)
{
- g_assert (n_pfds == watch_pfds.size());
+ assert (n_pfds == watch_pfds.size());
copy (watch_pfds.begin(), watch_pfds.end(), pfds);
for (guint i = 0; i < watches.size(); i++)
watches[i].notify_pfds = pfds + watches[i].index;
@@ -215,7 +215,7 @@ Sequencer::pool_poll_Lm (gint timeout_ms)
GPollFD *watch_pfds;
while (poll_pool_->fetch_notify_watch (current_watch_func, current_watch_data, watch_n_pfds,
watch_pfds))
{
- g_assert (!current_watch_needs_remove1 && !current_watch_needs_remove2);
+ assert (!current_watch_needs_remove1 && !current_watch_needs_remove2);
BSE_SEQUENCER_UNLOCK();
bool current_watch_stays_alive = current_watch_func (current_watch_data, watch_n_pfds, watch_pfds);
BSE_SEQUENCER_LOCK();
@@ -239,7 +239,7 @@ Sequencer::start_song (BseSong *song, uint64 start_stamp)
assert_return (BSE_IS_SONG (song));
assert_return (BSE_SOURCE_PREPARED (song));
assert_return (song->sequencer_start_request_SL == 0);
- g_assert (song->sequencer_owns_refcount_SL == false);
+ assert (song->sequencer_owns_refcount_SL == false);
start_stamp = MAX (start_stamp, 1);
g_object_ref (song);
@@ -268,7 +268,7 @@ Sequencer::remove_song (BseSong *song)
assert_return (BSE_SOURCE_PREPARED (song));
if (song->sequencer_start_request_SL == 0)
{
- g_assert (song->sequencer_owns_refcount_SL == false);
+ assert (song->sequencer_owns_refcount_SL == false);
return; // uncontained
}
BSE_SEQUENCER_LOCK();
diff --git a/bse/bseserver.cc b/bse/bseserver.cc
index 1f39e72..3021be8 100644
--- a/bse/bseserver.cc
+++ b/bse/bseserver.cc
@@ -146,7 +146,7 @@ rc_file_try_statement (gpointer context_data,
gpointer user_data)
{
BseServer *server = (BseServer*) context_data;
- g_assert (scanner->next_token == G_TOKEN_IDENTIFIER);
+ assert (scanner->next_token == G_TOKEN_IDENTIFIER);
if (strcmp ("bse-preferences", scanner->next_value.v_identifier) == 0)
{
GValue *value = sfi_value_rec (NULL);
@@ -169,7 +169,7 @@ rc_file_try_statement (gpointer context_data,
static void
bse_server_init (BseServer *self)
{
- g_assert (BSE_OBJECT_ID (self) == 1); /* assert being the first object */
+ assert (BSE_OBJECT_ID (self) == 1); /* assert being the first object */
BSE_OBJECT_SET_FLAGS (self, BSE_ITEM_FLAG_SINGLETON);
self->engine_source = NULL;
@@ -884,7 +884,7 @@ main_thread_source_setup (BseServer *self)
MainSource *xsource = (MainSource*) source;
static gboolean single_call = 0;
- g_assert (single_call++ == 0);
+ assert (single_call++ == 0);
xsource->server = self;
g_source_set_priority (source, BSE_PRIORITY_NORMAL);
diff --git a/bse/bsesnet.cc b/bse/bsesnet.cc
index f6a54a1..5180baf 100644
--- a/bse/bsesnet.cc
+++ b/bse/bsesnet.cc
@@ -732,7 +732,7 @@ bse_snet_context_clone_branch (BseSNet *self,
ContextData *cdata;
SfiRing *node;
- g_assert (self->tmp_context_children == NULL);
+ assert (self->tmp_context_children == NULL);
for (node = ring; node; node = sfi_ring_walk (node, ring))
self->tmp_context_children = g_slist_prepend (self->tmp_context_children, node->data);
self->tmp_context_children = g_slist_prepend (self->tmp_context_children, context_merger);
@@ -740,7 +740,7 @@ bse_snet_context_clone_branch (BseSNet *self,
bcid = bse_id_alloc ();
cdata = create_context_data (self, bcid, context, mcontext.midi_receiver, mcontext.midi_channel);
bse_source_create_context_with_data (BSE_SOURCE (self), bcid, cdata, free_context_data, trans);
- g_assert (self->tmp_context_children == NULL);
+ assert (self->tmp_context_children == NULL);
}
else
{
@@ -851,7 +851,7 @@ bse_snet_context_create (BseSource *source,
BseContextMerger *context_merger = (BseContextMerger*) self->tmp_context_children->data;
ContextData *cdata = find_context_data (self, context_handle);
- g_assert (BSE_IS_CONTEXT_MERGER (context_merger));
+ assert (BSE_IS_CONTEXT_MERGER (context_merger));
bse_context_merger_set_merge_context (context_merger, cdata->parent_context);
/* chain parent class' handler */
@@ -946,7 +946,7 @@ BSE_BUILTIN_TYPE (BseSNet)
0 /* n_preallocs */,
(GInstanceInitFunc) bse_snet_init,
};
- g_assert (BSE_SNET_FLAGS_USHIFT < BSE_OBJECT_FLAGS_MAX_SHIFT);
+ assert (BSE_SNET_FLAGS_USHIFT < BSE_OBJECT_FLAGS_MAX_SHIFT);
return bse_type_register_abstract (BSE_TYPE_SUPER, "BseSNet", "BSE Synthesis (Filter) Network", __FILE__,
__LINE__, &type_info);
}
diff --git a/bse/bsesnooper.cc b/bse/bsesnooper.cc
index a1feba2..0d7e3b1 100644
--- a/bse/bsesnooper.cc
+++ b/bse/bsesnooper.cc
@@ -90,7 +90,7 @@ bse_snooper_class_init (BseSnooperClass *klass)
SFI_PARAM_STANDARD));
ichannel = bse_source_class_add_ichannel (source_class, "signal-in", _("Signal In"), _("Snoop Signal"));
- g_assert (ichannel == BSE_SNOOPER_ICHANNEL_MONO);
+ assert (ichannel == BSE_SNOOPER_ICHANNEL_MONO);
}
static void
diff --git a/bse/bsesong.cc b/bse/bsesong.cc
index 62501c3..5dbc6a5 100644
--- a/bse/bsesong.cc
+++ b/bse/bsesong.cc
@@ -510,7 +510,7 @@ bse_song_reset (BseSource *source)
Bse::Sequencer::instance().remove_song (self);
// chain parent class' handler
BSE_SOURCE_CLASS (parent_class)->reset (source);
- g_assert (self->sequencer_start_request_SL == 0);
+ assert (self->sequencer_start_request_SL == 0);
/* outside of sequencer reach, so no locks needed */
self->sequencer_start_SL = 0;
self->sequencer_done_SL = 0;
@@ -529,7 +529,7 @@ bse_song_create_summation (BseSong *self)
if (!g_type_is_a (type, BSE_TYPE_SOURCE))
g_error ("%s: failed to resolve %s object type, probably missing or broken plugin installation",
G_STRFUNC, "BseSummation");
BseSource *summation = (BseSource*) bse_container_new_child (BSE_CONTAINER (self), type, "uname",
"Summation", NULL);
- g_assert (summation != NULL);
+ assert (summation != NULL);
bse_snet_intern_child (BSE_SNET (self), summation);
return summation;
}
diff --git a/bse/bsesource.cc b/bse/bsesource.cc
index 06971b1..f15310b 100644
--- a/bse/bsesource.cc
+++ b/bse/bsesource.cc
@@ -469,7 +469,7 @@ bse_source_set_automation_property (BseSource *source,
guint midi_channel,
Bse::MidiSignalType signal_type)
{
- g_assert (BSE_MIDI_CONTROL_NONE == BseMidiControlType (0) &&
+ assert (BSE_MIDI_CONTROL_NONE == BseMidiControlType (0) &&
BSE_MIDI_CONTROL_CONTINUOUS_0 == BseMidiControlType (Bse::MIDI_SIGNAL_CONTINUOUS_0) &&
BSE_MIDI_CONTROL_CONTINUOUS_31 == BseMidiControlType (Bse::MIDI_SIGNAL_CONTINUOUS_31) &&
BSE_MIDI_CONTROL_0 == BseMidiControlType (Bse::MIDI_SIGNAL_CONTROL_0) &&
@@ -2053,7 +2053,7 @@ BSE_BUILTIN_TYPE (BseSource)
(GInstanceInitFunc) bse_source_init,
};
- g_assert (BSE_SOURCE_FLAGS_USHIFT < BSE_OBJECT_FLAGS_MAX_SHIFT);
+ assert (BSE_SOURCE_FLAGS_USHIFT < BSE_OBJECT_FLAGS_MAX_SHIFT);
return bse_type_register_abstract (BSE_TYPE_ITEM,
"BseSource",
diff --git a/bse/bsestandardosc.cc b/bse/bsestandardosc.cc
index 6fe4b06..dfb075f 100644
--- a/bse/bsestandardosc.cc
+++ b/bse/bsestandardosc.cc
@@ -180,17 +180,17 @@ bse_standard_osc_class_init (BseStandardOscClass *klass)
SFI_PARAM_STANDARD ":f:dial"));
ichannel = bse_source_class_add_ichannel (source_class, "freq-in", _("Freq In"), _("Oscillating Frequency
Input"));
- g_assert (ichannel == BSE_STANDARD_OSC_ICHANNEL_FREQ);
+ assert (ichannel == BSE_STANDARD_OSC_ICHANNEL_FREQ);
ichannel = bse_source_class_add_ichannel (source_class, "freq-mod-in", _("Freq Mod In"), _("Frequency
Modulation Input"));
- g_assert (ichannel == BSE_STANDARD_OSC_ICHANNEL_FREQ_MOD);
+ assert (ichannel == BSE_STANDARD_OSC_ICHANNEL_FREQ_MOD);
ichannel = bse_source_class_add_ichannel (source_class, "pwm-in", _("PWM In"), _("Pulse Width Modulation
Input"));
- g_assert (ichannel == BSE_STANDARD_OSC_ICHANNEL_PWM);
+ assert (ichannel == BSE_STANDARD_OSC_ICHANNEL_PWM);
ichannel = bse_source_class_add_ichannel (source_class, "sync-in", _("Sync In"), _("Syncronization
Input"));
- g_assert (ichannel == BSE_STANDARD_OSC_ICHANNEL_SYNC);
+ assert (ichannel == BSE_STANDARD_OSC_ICHANNEL_SYNC);
ochannel = bse_source_class_add_ochannel (source_class, "audio-out", _("Audio Out"), _("Oscillated
Output"));
- g_assert (ochannel == BSE_STANDARD_OSC_OCHANNEL_OSC);
+ assert (ochannel == BSE_STANDARD_OSC_OCHANNEL_OSC);
ochannel = bse_source_class_add_ochannel (source_class, "sync-out", _("Sync Out"), _("Syncronization
Output"));
- g_assert (ochannel == BSE_STANDARD_OSC_OCHANNEL_SYNC);
+ assert (ochannel == BSE_STANDARD_OSC_OCHANNEL_SYNC);
}
static void
diff --git a/bse/bsestorage.cc b/bse/bsestorage.cc
index f1eb725..e31f13e 100644
--- a/bse/bsestorage.cc
+++ b/bse/bsestorage.cc
@@ -89,7 +89,7 @@ BSE_BUILTIN_TYPE (BseStorage)
(GInstanceInitFunc) bse_storage_init,
};
- g_assert (BSE_STORAGE_FLAGS_USHIFT < BSE_OBJECT_FLAGS_MAX_SHIFT);
+ assert (BSE_STORAGE_FLAGS_USHIFT < BSE_OBJECT_FLAGS_MAX_SHIFT);
return bse_type_register_static (BSE_TYPE_OBJECT, "BseStorage",
"Storage object for item serialization",
diff --git a/bse/bsesubiport.cc b/bse/bsesubiport.cc
index 3365301..be53552 100644
--- a/bse/bsesubiport.cc
+++ b/bse/bsesubiport.cc
@@ -278,7 +278,7 @@ bse_sub_iport_class_init (BseSubIPortClass *klass)
ident = g_strdup_format ("output-%u", i + 1);
label = g_strdup_format (_("Virtual input %u"), i + 1);
channel_id = bse_source_class_add_ochannel (source_class, ident, label, NULL);
- g_assert (channel_id == i);
+ assert (channel_id == i);
g_free (ident);
g_free (label);
diff --git a/bse/bsesuboport.cc b/bse/bsesuboport.cc
index d725dce..38dc15b 100644
--- a/bse/bsesuboport.cc
+++ b/bse/bsesuboport.cc
@@ -279,7 +279,7 @@ bse_sub_oport_class_init (BseSubOPortClass *klass)
ident = g_strdup_format ("input-%u", i + 1);
label = g_strdup_format (_("Virtual output %u"), i + 1);
channel_id = bse_source_class_add_ichannel (source_class, ident, label, NULL);
- g_assert (channel_id == i);
+ assert (channel_id == i);
g_free (ident);
g_free (label);
diff --git a/bse/bsesubsynth.cc b/bse/bsesubsynth.cc
index 86f9d0e..b554a20 100644
--- a/bse/bsesubsynth.cc
+++ b/bse/bsesubsynth.cc
@@ -338,7 +338,7 @@ bse_sub_synth_context_create (BseSource *source,
recursion_stack = g_slist_prepend (recursion_stack, self);
foreign_context_handle = bse_snet_create_context (snet, mcontext, trans);
recursion_stack = g_slist_remove (recursion_stack, self);
- g_assert (foreign_context_handle > 0);
+ assert (foreign_context_handle > 0);
}
else
shortcut = self->null_shortcut;
@@ -522,14 +522,14 @@ bse_sub_synth_class_init (BseSubSynthClass *klass)
ident = g_strdup_format ("input-%u", i + 1);
label = g_strdup_format (_("Virtual input %u"), i + 1);
channel_id = bse_source_class_add_ichannel (source_class, ident, label, NULL);
- g_assert (channel_id == i);
+ assert (channel_id == i);
g_free (ident);
g_free (label);
ident = g_strdup_format ("output-%u", i + 1);
label = g_strdup_format (_("Virtual output %u"), i + 1);
channel_id = bse_source_class_add_ochannel (source_class, ident, label, NULL);
- g_assert (channel_id == i);
+ assert (channel_id == i);
g_free (ident);
g_free (label);
}
diff --git a/bse/bsetrack.cc b/bse/bsetrack.cc
index 238399f..0acb8ad 100644
--- a/bse/bsetrack.cc
+++ b/bse/bsetrack.cc
@@ -120,17 +120,17 @@ bse_track_dispose (GObject *object)
/* we may assert removal here, since if these assertions fail,
* our parent (BseSong) doesn't properly implement track support
*/
- g_assert (self->sub_synth == NULL);
+ assert (self->sub_synth == NULL);
/* check uncrossed references */
- g_assert (self->snet == NULL);
- g_assert (self->pnet == NULL);
- g_assert (self->n_entries_SL == 0);
+ assert (self->snet == NULL);
+ assert (self->pnet == NULL);
+ assert (self->n_entries_SL == 0);
/* chain parent class' handler */
G_OBJECT_CLASS (parent_class)->dispose (object);
- g_assert (self->bus_outputs == NULL);
+ assert (self->bus_outputs == NULL);
}
static void
@@ -138,9 +138,9 @@ bse_track_finalize (GObject *object)
{
BseTrack *self = BSE_TRACK (object);
- g_assert (self->bus_outputs == NULL);
+ assert (self->bus_outputs == NULL);
- g_assert (self->n_entries_SL == 0);
+ assert (self->n_entries_SL == 0);
g_free (self->entries_SL);
bse_id_free (self->channel_id);
diff --git a/bse/bsetype.cc b/bse/bsetype.cc
index 1e45d4d..11afb7a 100644
--- a/bse/bsetype.cc
+++ b/bse/bsetype.cc
@@ -424,7 +424,7 @@ bse_type_init (void)
bse_type_register_procedure_info (&info);
g_type_register_fundamental (BSE_TYPE_PROCEDURE, "BseProcedure", &info, &finfo, GTypeFlags (0));
bse_type_add_blurb (BSE_TYPE_PROCEDURE, "BSE Procedure base type", __FILE__, __LINE__);
- g_assert (BSE_TYPE_PROCEDURE == g_type_from_name ("BseProcedure"));
+ assert (BSE_TYPE_PROCEDURE == g_type_from_name ("BseProcedure"));
/* initialize extra types */
{
diff --git a/bse/bsewaveosc.cc b/bse/bsewaveosc.cc
index 7349efc..e454d73 100644
--- a/bse/bsewaveosc.cc
+++ b/bse/bsewaveosc.cc
@@ -573,15 +573,15 @@ bse_wave_osc_class_init (BseWaveOscClass *klass)
G_TYPE_INT);
ichannel = bse_source_class_add_ichannel (source_class, "freq-in", _("Freq In"), _("Frequency Input"));
- g_assert (ichannel == BSE_WAVE_OSC_ICHANNEL_FREQ);
+ assert (ichannel == BSE_WAVE_OSC_ICHANNEL_FREQ);
ichannel = bse_source_class_add_ichannel (source_class, "sync-in", _("Sync In"), _("Syncronization
Input"));
- g_assert (ichannel == BSE_WAVE_OSC_ICHANNEL_SYNC);
+ assert (ichannel == BSE_WAVE_OSC_ICHANNEL_SYNC);
ichannel = bse_source_class_add_ichannel (source_class, "mod-in", _("Mod In"), _("Modulation Input"));
- g_assert (ichannel == BSE_WAVE_OSC_ICHANNEL_MOD);
+ assert (ichannel == BSE_WAVE_OSC_ICHANNEL_MOD);
ochannel = bse_source_class_add_ochannel (source_class, "audio-out", _("Audio Out"), _("Wave Output"));
- g_assert (ochannel == BSE_WAVE_OSC_OCHANNEL_WAVE);
+ assert (ochannel == BSE_WAVE_OSC_OCHANNEL_WAVE);
ochannel = bse_source_class_add_ochannel (source_class, "gate-out", _("Gate Out"), _("Gate Output"));
- g_assert (ochannel == BSE_WAVE_OSC_OCHANNEL_GATE);
+ assert (ochannel == BSE_WAVE_OSC_OCHANNEL_GATE);
ochannel = bse_source_class_add_ochannel (source_class, "done-out", _("Done Out"), _("Done Output"));
- g_assert (ochannel == BSE_WAVE_OSC_OCHANNEL_DONE);
+ assert (ochannel == BSE_WAVE_OSC_OCHANNEL_DONE);
}
diff --git a/bse/gsldatacache.cc b/bse/gsldatacache.cc
index 4436d12..e7d4c42 100644
--- a/bse/gsldatacache.cc
+++ b/bse/gsldatacache.cc
@@ -53,7 +53,7 @@ void
_gsl_init_data_caches (void)
{
static gboolean initialized = FALSE;
- g_assert (initialized == FALSE);
+ assert (initialized == FALSE);
initialized++;
RAPICORN_STATIC_ASSERT (AGE_EPSILON < LOW_PERSISTENCY_RESIDENT_SET);
}
@@ -66,7 +66,7 @@ gsl_data_cache_new (GslDataHandle *dhandle,
assert_return (dhandle != NULL, NULL);
assert_return (padding > 0, NULL);
assert_return (dhandle->name != NULL, NULL);
- g_assert (node_size == sfi_alloc_upper_power2 (node_size));
+ assert (node_size == sfi_alloc_upper_power2 (node_size));
assert_return (padding < node_size / 2, NULL);
/* allocate new closed dcache if necessary */
dcache = sfi_new_struct (GslDataCache, 1);
@@ -468,7 +468,7 @@ gsl_data_cache_unref_node (GslDataCache *dcache,
assert_return (node->ref_count > 0);
dcache->mutex.lock();
node_p = data_cache_lookup_nextmost_node_L (dcache, node->offset);
- g_assert (node_p && *node_p == node); /* paranoid check lookup, yeah! */
+ assert (node_p && *node_p == node); /* paranoid check lookup, yeah! */
node->ref_count -= 1;
check_cache = !node->ref_count;
if (!node->ref_count &&
diff --git a/bse/gsldatahandle-mad.cc b/bse/gsldatahandle-mad.cc
index 2091418..4f43006 100644
--- a/bse/gsldatahandle-mad.cc
+++ b/bse/gsldatahandle-mad.cc
@@ -464,7 +464,7 @@ dh_mad_read (GslDataHandle *dhandle,
/* suckage, need to do lengthy seek in file */
tmp = dh_mad_coarse_seek (dhandle, voffset);
- g_assert (tmp <= voffset);
+ assert (tmp <= voffset);
}
while (pos >= handle->pcm_pos + handle->pcm_length)
diff --git a/bse/gsldatahandle-vorbis.cc b/bse/gsldatahandle-vorbis.cc
index 4ae9692..ef791d5 100644
--- a/bse/gsldatahandle-vorbis.cc
+++ b/bse/gsldatahandle-vorbis.cc
@@ -305,7 +305,7 @@ dh_vorbis_read (GslDataHandle *dhandle,
/* suckage, needs to seek in file, this takes ages */
tmp = dh_vorbis_coarse_seek (dhandle, voffset);
- g_assert (tmp <= voffset);
+ assert (tmp <= voffset);
}
while (pos >= vhandle->pcm_pos + vhandle->pcm_length)
diff --git a/bse/gsldatahandle.cc b/bse/gsldatahandle.cc
index 1e4ed06..ae4d0d3 100644
--- a/bse/gsldatahandle.cc
+++ b/bse/gsldatahandle.cc
@@ -723,7 +723,7 @@ reverse_handle_read (GslDataHandle *dhandle,
int64 left, new_offset = dhandle->setup.n_values - (voffset + n_values);
gfloat *t, *p = values;
- g_assert (new_offset >= 0);
+ assert (new_offset >= 0);
left = n_values;
do
diff --git a/bse/gsldatautils.cc b/bse/gsldatautils.cc
index 8662f7d..8f72a30 100644
--- a/bse/gsldatautils.cc
+++ b/bse/gsldatautils.cc
@@ -522,7 +522,7 @@ tailmatch_score_loop (GslDataHandle *shandle,
gfloat v1[GSL_DATA_HANDLE_PEEK_BUFFER], v2[GSL_DATA_HANDLE_PEEK_BUFFER];
gdouble score = 0;
- g_assert (start < length);
+ assert (start < length);
for (l = start; l < length; )
{
@@ -530,7 +530,7 @@ tailmatch_score_loop (GslDataHandle *shandle,
b = gsl_data_handle_read (shandle, l, b, v1);
b = gsl_data_handle_read (dhandle, l, b, v2);
- g_assert (b >= 1); // FIXME
+ assert (b >= 1); // FIXME
l += b;
while (b--)
@@ -785,7 +785,7 @@ gsl_data_clip_sample (GslDataHandle *dhandle,
return result->error;
}
SfiNum tail = gsl_data_find_sample (dhandle, +cconfig->threshold, -cconfig->threshold, -1, -1);
- g_assert (tail >= 0);
+ assert (tail >= 0);
/* verify silence detection */
if (last_value - tail < cconfig->tail_samples)
diff --git a/bse/gslfilehash.cc b/bse/gslfilehash.cc
index 2461e13..f24c327 100644
--- a/bse/gslfilehash.cc
+++ b/bse/gslfilehash.cc
@@ -39,7 +39,7 @@ hfile_equals (gconstpointer key1,
void
_gsl_init_fd_pool (void)
{
- g_assert (hfile_ht == NULL);
+ assert (hfile_ht == NULL);
hfile_ht = g_hash_table_new (hfile_hash, hfile_equals);
}
static gboolean
diff --git a/bse/gslvorbis-enc.cc b/bse/gslvorbis-enc.cc
index 95f36e9..bca31bc 100644
--- a/bse/gslvorbis-enc.cc
+++ b/bse/gslvorbis-enc.cc
@@ -302,7 +302,7 @@ vorbis_encoder_write_pcm_1k (GslVorbisEncoder *self,
/* the vorbis encoding engine has a bug that produces junk at
* certain block sizes beyond 1024
*/
- g_assert (n_values <= 1024);
+ assert (n_values <= 1024);
/* people passing in non-channel-aligned data get what they deserve */
n_values /= self->n_channels;
diff --git a/bse/gslwavechunk.cc b/bse/gslwavechunk.cc
index 153532a..25ae012 100644
--- a/bse/gslwavechunk.cc
+++ b/bse/gslwavechunk.cc
@@ -460,7 +460,7 @@ gsl_wave_chunk_use_block (GslWaveChunk *wchunk,
reverse = FALSE;
block->length = (iter.ubound - iter.rel_pos) / wchunk->n_channels;
block->length *= wchunk->n_channels;
- g_assert (block->length <= STATIC_ZERO_SIZE - 2 * wchunk->n_pad_values);
+ assert (block->length <= STATIC_ZERO_SIZE - 2 * wchunk->n_pad_values);
block->start = static_zero_block + iter.rel_pos;
}
else
@@ -510,7 +510,7 @@ gsl_wave_chunk_use_block (GslWaveChunk *wchunk,
block->dirstride = +wchunk->n_channels;
block->end = block->start + block->length;
}
- g_assert (block->length > 0);
+ assert (block->length > 0);
/* we might want to partly reset this at some point to implement
* truely infinite loops
*/
diff --git a/bse/gslwaveosc.cc b/bse/gslwaveosc.cc
index 7413154..f708149 100644
--- a/bse/gslwaveosc.cc
+++ b/bse/gslwaveosc.cc
@@ -205,8 +205,8 @@ gsl_wave_osc_process (GslWaveOscData *wosc,
wosc->y[i] = 0.0;
}
}
- g_assert (!BSE_DOUBLE_IS_NANINF (wosc->y[0]));
- g_assert (!BSE_DOUBLE_IS_SUBNORMAL (wosc->y[0]));
+ assert (!BSE_DOUBLE_IS_NANINF (wosc->y[0]));
+ assert (!BSE_DOUBLE_IS_SUBNORMAL (wosc->y[0]));
wosc->done = (wosc->block.is_silent && /* FIXME, let filter state run out? */
((wosc->block.play_dir < 0 && wosc->block.offset < 0) ||
@@ -370,7 +370,7 @@ gsl_wave_osc_init (GslWaveOscData *wosc)
{
assert_return (wosc != NULL);
- g_assert (GSL_WAVE_OSC_FILTER_ORDER <= BSE_CONFIG (wave_chunk_padding));
+ assert (GSL_WAVE_OSC_FILTER_ORDER <= BSE_CONFIG (wave_chunk_padding));
memset (wosc, 0, sizeof (GslWaveOscData));
wosc->mix_freq = bse_engine_sample_freq ();
diff --git a/bse/tests/blocktests.cc b/bse/tests/blocktests.cc
index 92a2188..2d237fe 100644
--- a/bse/tests/blocktests.cc
+++ b/bse/tests/blocktests.cc
@@ -268,7 +268,7 @@ bench_copy (void)
if (e < m)
m = e;
}
- g_assert (dest_fblock[0] == 2.f);
+ assert (dest_fblock[0] == 2.f);
report_usecs ("Block::copy", 1000000.0 * m / dups * BENCH_SCALE);
if (0)
g_print ("CopyBench: %.6f msecs (test-duration: %.6f calibration: %.6f)\n",
@@ -356,7 +356,7 @@ bench_mul (void)
if (e < m)
m = e;
}
- g_assert (fblock1[0] < 1e30); /* not close to infinity */
+ assert (fblock1[0] < 1e30); /* not close to infinity */
report_usecs ("Block::mul", 1000000.0 * m / dups * BENCH_SCALE);
if (0)
g_print ("MulBench: %.6f msecs (test-duration: %.6f calibration: %.6f)\n",
@@ -422,8 +422,8 @@ bench_range (void)
if (e < m)
m = e;
}
- g_assert (min_value == correct_min_value);
- g_assert (max_value == correct_max_value);
+ assert (min_value == correct_min_value);
+ assert (max_value == correct_max_value);
report_usecs ("Block::range", 1000000.0 * m / dups * BENCH_SCALE);
if (0)
g_print ("RangeBench: %.6f msecs (test-duration: %.6f calibration: %.6f)\n",
@@ -488,8 +488,8 @@ bench_range_and_square_sum (void)
if (e < m)
m = e;
}
- g_assert (min_value == correct_min_value);
- g_assert (max_value == correct_max_value);
+ assert (min_value == correct_min_value);
+ assert (max_value == correct_max_value);
report_usecs ("Block::range_and_square_sum", 1000000.0 * m / dups * BENCH_SCALE);
if (0)
g_print ("Range+SquareSumBench: %.6f msecs (test-duration: %.6f calibration: %.6f)\n",
diff --git a/bse/tests/firhandle.cc b/bse/tests/firhandle.cc
index 0cbdcf7..40cd6d4 100644
--- a/bse/tests/firhandle.cc
+++ b/bse/tests/firhandle.cc
@@ -25,11 +25,11 @@ read_through (GslDataHandle *handle)
// we don't use 1024 here, because we know that it is the FIR handle internal buffer size
gfloat values[700];
int64 values_read = gsl_data_handle_read (handle, offset, 700, values);
- g_assert (values_read > 0);
+ assert (values_read > 0);
offset += values_read;
}
- g_assert (offset == n_values);
+ assert (offset == n_values);
}
static double
@@ -54,7 +54,7 @@ band_min (const vector<double>& scanned_freq,
double start_freq,
double end_freq)
{
- g_assert (scanned_freq.size() == scanned_values.size());
+ assert (scanned_freq.size() == scanned_values.size());
bool init = false;
double min_value = 1e19;
@@ -71,7 +71,7 @@ band_min (const vector<double>& scanned_freq,
}
}
}
- g_assert (init);
+ assert (init);
return min_value;
}
@@ -81,7 +81,7 @@ band_max (const vector<double>& scanned_freq,
double start_freq,
double end_freq)
{
- g_assert (scanned_freq.size() == scanned_values.size());
+ assert (scanned_freq.size() == scanned_values.size());
bool init = false;
double max_value = -1e19;
@@ -98,7 +98,7 @@ band_max (const vector<double>& scanned_freq,
}
}
}
- g_assert (init);
+ assert (init);
return max_value;
}
diff --git a/bse/tests/resamplehandle.cc b/bse/tests/resamplehandle.cc
index dab2e25..4e6f751 100644
--- a/bse/tests/resamplehandle.cc
+++ b/bse/tests/resamplehandle.cc
@@ -24,11 +24,11 @@ read_through (GslDataHandle *handle)
{
gfloat values[1024];
int64 values_read = gsl_data_handle_read (handle, offset, 1024, values);
- g_assert (values_read > 0);
+ assert (values_read > 0);
offset += values_read;
}
- g_assert (offset == n_values);
+ assert (offset == n_values);
}
static double
@@ -342,7 +342,7 @@ test_delay_compensation (const char *run_type)
if (j % 2)
{
/* implement half a output sample delay (for downsampling only) */
- g_assert (params[p].mode == BSE_RESAMPLER2_MODE_DOWNSAMPLE);
+ assert (params[p].mode == BSE_RESAMPLER2_MODE_DOWNSAMPLE);
i++;
j += 2;
}
diff --git a/bse/tests/subnormals.cc b/bse/tests/subnormals.cc
index b849a9a..3cbd68e 100644
--- a/bse/tests/subnormals.cc
+++ b/bse/tests/subnormals.cc
@@ -34,11 +34,11 @@ test_correct_subnormal_elimination (const char* algo_name)
for (int i = 1; i < n; i++)
{
float value = BSE_FLOAT_MAX_SUBNORMAL * i / n;
- g_assert (BSE_FLOAT_IS_SUBNORMAL (value));
+ assert (BSE_FLOAT_IS_SUBNORMAL (value));
float normalized_positive_value = Func (value);
- g_assert (!BSE_FLOAT_IS_SUBNORMAL (normalized_positive_value));
+ assert (!BSE_FLOAT_IS_SUBNORMAL (normalized_positive_value));
float normalized_negative_value = Func (-value);
- g_assert (!BSE_FLOAT_IS_SUBNORMAL (normalized_negative_value));
+ assert (!BSE_FLOAT_IS_SUBNORMAL (normalized_negative_value));
if (i % 100000 == 0)
TOK();
}
@@ -53,11 +53,11 @@ test_correct_subnormal_elimination (const char* algo_name)
for (int i = 1; i < n; i++)
{
double value = BSE_DOUBLE_MAX_SUBNORMAL * i / n;
- g_assert (BSE_DOUBLE_IS_SUBNORMAL (value));
+ assert (BSE_DOUBLE_IS_SUBNORMAL (value));
double normalized_positive_value = Func (value);
- g_assert (!BSE_DOUBLE_IS_SUBNORMAL (normalized_positive_value));
+ assert (!BSE_DOUBLE_IS_SUBNORMAL (normalized_positive_value));
double normalized_negative_value = Func (-value);
- g_assert (!BSE_DOUBLE_IS_SUBNORMAL (normalized_negative_value));
+ assert (!BSE_DOUBLE_IS_SUBNORMAL (normalized_negative_value));
if (i % 100000 == 0)
TOK();
}
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
