/* Branch prediction */
#ifdef __GNUC__
-# define likely(p) __builtin_expect(!!(p), 1)
-# define unlikely(p) __builtin_expect(!!(p), 0)
+# define likely(p) __builtin_expect(!!(p), 1)
+# define unlikely(p) __builtin_expect(!!(p), 0)
+# define unreachable() __builtin_unreachable()
#else
-# define likely(p) (!!(p))
-# define unlikely(p) (!!(p))
+# define likely(p) (!!(p))
+# define unlikely(p) (!!(p))
+# define unreachable() ((void)0)
#endif
+#define vlc_assert_unreachable() (assert(!"unreachable"), unreachable())
+
/* Linkage */
#ifdef __cplusplus
# define VLC_EXTERN extern "C"
free(listener);
fprintf( stderr, "This object event manager doesn't know about '%s' events",
libvlc_event_type_name(event_type) );
- assert(0);
+ vlc_assert_unreachable();
return -1;
}
bd_mouse_select(p_sys->bluray, now, val.coords.x, val.coords.y);
bd_user_input(p_sys->bluray, now, BD_VK_MOUSE_ACTIVATE);
} else {
- assert(0);
+ vlc_assert_unreachable();
}
return VLC_SUCCESS;
}
case CA_CI:
return;
default:
- assert( 0 );
+ vlc_assert_unreachable();
}
for ( unsigned i_slot = 0; i_slot < p_cam->i_nb_slots; i_slot++ )
static int NoSeek (access_t *p_access, uint64_t i_pos)
{
- /* assert(0); ?? */
+ /* vlc_assert_unreachable(); ?? */
(void) p_access; (void) i_pos;
return VLC_EGENERIC;
}
break;
default:
- assert(0);
+ vlc_assert_unreachable();
}
if( p_sys->i_code == 401 )
msleep (((int64_t)p_timeout->p_sys->i_timeout - 2) * CLOCK_FREQ);
}
- assert(0); /* dead code */
+ vlc_assert_unreachable(); /* dead code */
}
/*****************************************************************************
msleep( 10 * CLOCK_FREQ );
}
- assert(0);
+ vlc_assert_unreachable();
}
static void KeepAliveStart( access_t *p_access )
ret = ControlSetStr (ctrl, cur.psz_string);
break;
default:
- assert (0);
+ vlc_assert_unreachable ();
}
if (ret)
#endif
}
- assert (0);
+ vlc_assert_unreachable ();
}
static void *ReadThread (void *data)
GrabVBI (demux, sys->vbi);
#endif
}
- assert (0);
+ vlc_assert_unreachable ();
}
static int DemuxControl( demux_t *demux, int query, va_list args )
if( (i_physical_channels & ~valid_channels[i]) == 0 )
return valid_channels[i];
- assert( false );
- return 0;
+ vlc_assert_unreachable();
}
/*****************************************************************************
fmt->i_physical_channels = AOUT_CHANS_7_1;
break;
default:
- assert(0);
+ vlc_assert_unreachable();
}
fmt->i_format = VLC_CODEC_S16N;
&p_sys->p_cmd->out.time_get.i_delay );
break;
default:
- assert( false );
- break;
+ vlc_assert_unreachable();
}
if( b_error )
p_sys->b_thread_run = false;
break;
default: /* unsubscribed facility?! */
- assert(0);
+ vlc_assert_unreachable();
}
}
return h->i_screen;
default:
/* It cannot happen, else it is a bug */
- assert( 0 );
+ vlc_assert_unreachable();
return 0;
}
}
p_dec->fmt_out.i_codec = VLC_CODEC_WIDI_LPCM;
break;
default:
- assert(0);
+ vlc_assert_unreachable();
case LPCM_BD:
p_dec->fmt_out.i_codec = VLC_CODEC_BD_LPCM;
break;
AobExtract( p_aout_buffer, p_block, i_bits, p_aob_group );
break;
default:
- assert(0);
+ vlc_assert_unreachable();
case LPCM_BD:
BdExtract( p_aout_buffer, p_block, i_frame_length, i_channels, i_channels_padding, i_bits );
break;
i_freq_code = 3;
break;
default:
- assert(0);
+ vlc_assert_unreachable();
}
int i_bytes_consumed = 0;
break;
}
default:
- assert(0);
+ vlc_assert_unreachable();
}
free( p_events[i] );
}
else if( !strcmp( "can-pause", psz_var ) )
info.signal = SIGNAL_CAN_PAUSE;
else
- assert(0);
+ vlc_assert_unreachable();
if( info.signal == SIGNAL_NONE )
return VLC_SUCCESS;
vlc_restorecancel( canc );
}
- assert(0);
+ vlc_assert_unreachable();
}
#undef LOW_THRESHOLD
#undef HIGH_THRESHOLD
return 0;
#endif
default:
- assert( 0 );
+ vlc_assert_unreachable();
}
}
}
else
/* This case can't happen */
- assert( 0 );
+ vlc_assert_unreachable();
if( newval.psz_string && *newval.psz_string )
{
}
@catch (NSException * e) {
NSLog(@"Strange CGEventType: %d: %@", type, e);
- assert(0);
+ vlc_assert_unreachable();
return event;
}
ret = 3;
break;
default:
- assert(0);
+ vlc_assert_unreachable();
ret = 0;
break;
}
return spinner;
}
default:
- assert(0);
+ vlc_assert_unreachable();
return nil;
}
return i_playlist_id;
default:
case MLMEDIA_ID:
- assert( 0 );
+ vlc_assert_unreachable();
return -1;
}
}
#endif
showView( ICON_VIEW );
else
- assert( 0 );
+ vlc_assert_unreachable();
}
void StandardPLPanel::activate( const QModelIndex &index )
caption = "Icecast";
break;
default:
- assert(0);
+ vlc_assert_unreachable();
return;
}
break;
default:
msg_Warn( p_intf, "This shouldn't happen: %i", i_type );
- assert(0);
+ vlc_assert_unreachable();
}
}
p_wnd->handle.nsobject = (void *)wid;
break;
default:
- assert(0);
+ vlc_assert_unreachable();
}
p_wnd->control = WindowControl;
fmt.i_chroma = VLC_CODEC_VDPAU_VIDEO_444;
break;
default:
- assert(0);
+ vlc_assert_unreachable();
}
picture_t *dst = picture_NewFromFormat(&fmt);
case VDP_CHROMA_TYPE_420: fmt.i_chroma = VLC_CODEC_NV12; break;
case VDP_CHROMA_TYPE_422: fmt.i_chroma = VLC_CODEC_UYVY; break;
case VDP_CHROMA_TYPE_444: fmt.i_chroma = VLC_CODEC_NV24; break;
- default: assert(0);
+ default: vlc_assert_unreachable();
}
picture_t *pic = picture_NewFromFormat(&fmt);
vlc_restorecancel (canc);
}
vlc_cleanup_pop();
- assert(0); /* dead code */
+ vlc_assert_unreachable(); /* dead code */
}
static int UrlsChange( vlc_object_t *p_this, char const *psz_var,
else if( timeout < 200 )
timeout = 200; /* Don't wakeup too fast. */
}
- assert (0);
+ vlc_assert_unreachable ();
}
/**********************************************************************
vlc_restorecancel( canc );
}
- assert( 0 );
+ vlc_assert_unreachable();
}
c1 = c2 = 4;
break;
default:
- assert(0);
+ vlc_assert_unreachable();
}
if( asprintf( &rtp_fmt->fmtp,
i_xdec = i_ydec = 2;
break;
default:
- assert(0);
+ vlc_assert_unreachable();
}
static const int RTP_HEADER_LEN = 12;
p_outdata += i_length;
p_data += i_length;
}
- else assert(0);
+ else vlc_assert_unreachable();
}
/* rtp common header */
break;
default:
/* The above are the only possibilities, if there are no bugs. */
- assert(0);
+ vlc_assert_unreachable();
break;
}
}
RV32VerticalMirror( p_pic, p_outpic, i_plane, b_left_to_right );
break;
default:
- assert( false );
+ vlc_assert_unreachable();
}
}
PackedYUVPosterize( p_pic, p_outpic, level );
break;
default:
- assert( false );
+ vlc_assert_unreachable();
}
return CopyInfoAndRelease( p_outpic, p_pic );
u = *p_in++;
break;
default:
- assert( false );
+ vlc_assert_unreachable();
}
/* do posterization */
YuvPosterization( &posterized_y1, &posterized_y2, &posterized_u,
*p_out++ = posterized_u;
break;
default:
- assert( false );
+ vlc_assert_unreachable();
}
}
p_in += p_pic->p[0].i_pitch - p_pic->p[0].i_visible_pitch;
}
case VOUT_DISPLAY_RESET_PICTURES:
- assert (0);
+ vlc_assert_unreachable ();
default:
msg_Err (vd, "Unhandled request %d", query);
case VOUT_DISPLAY_CHANGE_FULLSCREEN:
break;
#ifndef NDEBUG
case VOUT_DISPLAY_RESET_PICTURES: // not needed
- assert(0);
+ vlc_assert_unreachable();
#endif
case VOUT_DISPLAY_CHANGE_DISPLAY_SIZE:
}
case VOUT_DISPLAY_RESET_PICTURES:
- assert (0);
+ vlc_assert_unreachable ();
default:
msg_Err(vd, "Unknown request %d", query);
case VOUT_DISPLAY_CHANGE_FULLSCREEN:
}
case VOUT_DISPLAY_RESET_PICTURES:
- assert (0);
+ vlc_assert_unreachable ();
default:
msg_Err (vd, "Unknown request in Mac OS X vout display");
return VLC_EGENERIC;
EventThreadMouseHide(sys->event);
return VLC_SUCCESS;
case VOUT_DISPLAY_RESET_PICTURES:
- assert(0);
+ vlc_assert_unreachable();
default:
return VLC_EGENERIC;
}
{
switch (query) {
case VOUT_DISPLAY_RESET_PICTURES:
- assert(0);
+ vlc_assert_unreachable();
return VLC_EGENERIC;
default:
return CommonControl(vd, query, args);
wl_display_read_events(display);
wl_display_dispatch_pending(display);
}
- assert(0);
+ vlc_assert_unreachable();
vlc_cleanup_pop();
//vlc_restorecancel(canc);
//return NULL;
return VLC_SUCCESS;
case VOUT_DISPLAY_RESET_PICTURES:
- assert (0);
+ vlc_assert_unreachable ();
default:
msg_Err (vd, "Unknown request in XCB vout display");
return VLC_EGENERIC;
xcb_flush (p_sys->conn);
return VLC_SUCCESS;
case VOUT_DISPLAY_RESET_PICTURES:
- assert(0);
+ vlc_assert_unreachable();
default:
msg_Err (vd, "Unknown request in XCB vout display");
return VLC_EGENERIC;
}
}
}
- assert(0);
+ vlc_assert_unreachable();
return VLC_EGENERIC;
}
vlc_restorecancel(canc);
}
- assert(0);
+ vlc_assert_unreachable();
}
block_Release( DoRealWork( p_filter, block ) );
vlc_restorecancel( canc );
}
- assert(0);
+ vlc_assert_unreachable();
}
static block_t *DoWork( filter_t *p_filter, block_t *p_in_buf )
}
default:
/* We should not reach here */
- assert(0);
+ vlc_assert_unreachable();
break;
}
cb = pthread_cond_timedwait_monotonic_np;
break;
default:
- assert (0);
+ vlc_assert_unreachable ();
}
int val = cb (&condvar->cond, p_mutex, &ts);
case VLC_CODEC_FL32: INTERLEAVE_TYPE(float); break;
case VLC_CODEC_S32N: INTERLEAVE_TYPE(int32_t); break;
case VLC_CODEC_FL64: INTERLEAVE_TYPE(double); break;
- default: assert(0);
+ default: vlc_assert_unreachable();
}
#undef INTERLEAVE_TYPE
}
case VLC_CODEC_FL32: DEINTERLEAVE_TYPE(float); break;
case VLC_CODEC_S32N: DEINTERLEAVE_TYPE(int32_t); break;
case VLC_CODEC_FL64: DEINTERLEAVE_TYPE(double); break;
- default: assert(0);
+ default: vlc_assert_unreachable();
}
#undef DEINTERLEAVE_TYPE
}
psz_path = "%s/Library/Caches/%s";
break;
default:
- assert(0);
+ vlc_assert_unreachable();
break;
}
void vlc_control_cancel (int cmd, ...)
{
(void) cmd;
- assert (0);
+ vlc_assert_unreachable ();
}
/* Precision monotonic clock.
case ES_OUT_RESTART_ES_BY_ID: i_new_query = ES_OUT_RESTART_ES; break;
case ES_OUT_SET_ES_DEFAULT_BY_ID: i_new_query = ES_OUT_SET_ES_DEFAULT; break;
default:
- assert(0);
+ vlc_assert_unreachable();
}
/* TODO if the lock is made non recursive it should be changed */
int i_ret = es_out_Control( out, i_new_query, p_es );
case ES_OUT_GET_ES_OBJECTS_BY_ID:
case ES_OUT_SET_DELAY:
case ES_OUT_SET_RECORD_STATE:
- assert(0);
+ vlc_assert_unreachable();
return VLC_EGENERIC;
/* Pass-through control */
default:
msg_Err( p_sys->p_input, "Unknown es_out_Control query !" );
- assert(0);
+ vlc_assert_unreachable();
return VLC_EGENERIC;
}
}
CmdExecuteDel( p_ts->p_out, &cmd );
break;
default:
- assert(0);
+ vlc_assert_unreachable();
break;
}
vlc_restorecancel( canc );
case C_DEL:
break;
default:
- assert(0);
+ vlc_assert_unreachable();
break;
}
}
}
default:
- assert(0);
+ vlc_assert_unreachable();
return VLC_EGENERIC;
}
p_cmd->u.control.u.jitter.i_cr_average );
default:
- assert(0);
+ vlc_assert_unreachable();
return VLC_EGENERIC;
}
}
case STREAM_METHOD_STREAM:
return AStreamSeekStream( s, offset );
default:
- assert(0);
+ vlc_assert_unreachable();
return VLC_EGENERIC;
}
}
}
FOREACH_END()
/* Unknown event = BUG */
- assert( 0 );
+ vlc_assert_unreachable();
}
/**
}
FOREACH_END()
- assert( 0 );
+ vlc_assert_unreachable();
}
p_var->ops = &void_ops;
break;
default:
- assert (0);
+ vlc_assert_unreachable ();
}
if( (i_type & VLC_VAR_DOINHERIT)
if( b_found_similar )
fprintf( stderr, "Calling var_DelCallback for '%s' with the same "
"function but not the same data.", psz_name );
- assert( 0 );
+ vlc_assert_unreachable();
#endif
vlc_mutex_unlock( &p_priv->var_lock );
return VLC_EGENERIC;
p_val->b_bool = config_GetInt( p_this, psz_name );
break;
default:
- assert(0);
+ vlc_assert_unreachable();
case VLC_VAR_ADDRESS:
return VLC_ENOOBJ;
}
char *httpd_ClientIP (const httpd_client_t *cl, char *psz_ip, int *port)
{
(void) cl; (void) psz_ip; (void) port;
- assert (0);
+ vlc_assert_unreachable ();
}
httpd_file_sys_t *httpd_FileDelete (httpd_file_t *file)
{
(void) file;
- assert (0);
+ vlc_assert_unreachable ();
}
httpd_file_t *httpd_FileNew (httpd_host_t *host,
(void) url; (void) content_type;
(void) login; (void) password;
(void) cb; (void) data;
- assert (0);
+ vlc_assert_unreachable ();
}
httpd_handler_sys_t *httpd_HandlerDelete (httpd_handler_t *handler)
{
(void) handler;
- assert (0);
+ vlc_assert_unreachable ();
}
httpd_handler_t *httpd_HandlerNew (httpd_host_t *host, const char *url,
(void) host; (void) url;
(void) login; (void) password;
(void) cb; (void) data;
- assert (0);
+ vlc_assert_unreachable ();
}
void httpd_HostDelete (httpd_host_t *h)
{
(void) h;
- assert (0);
+ vlc_assert_unreachable ();
}
httpd_host_t *vlc_http_HostNew (vlc_object_t *obj)
void httpd_MsgAdd (httpd_message_t *m, const char *name, const char *fmt, ...)
{
(void) m; (void) name; (void) fmt;
- assert (0);
+ vlc_assert_unreachable ();
}
const char *httpd_MsgGet (const httpd_message_t *m, const char *name)
{
(void) m; (void) name;
- assert (0);
+ vlc_assert_unreachable ();
}
void httpd_RedirectDelete (httpd_redirect_t *r)
{
(void) r;
- assert (0);
+ vlc_assert_unreachable ();
}
httpd_redirect_t *httpd_RedirectNew (httpd_host_t *host,
const char *dst, const char *src)
{
(void) host; (void) dst; (void) src;
- assert (0);
+ vlc_assert_unreachable ();
}
char *httpd_ServerIP (const httpd_client_t *client, char *ip, int *port)
{
(void) client; (void) ip; (void) port;
- assert (0);
+ vlc_assert_unreachable ();
}
void httpd_StreamDelete (httpd_stream_t *stream)
{
(void) stream;
- assert (0);
+ vlc_assert_unreachable ();
}
int httpd_StreamHeader (httpd_stream_t *stream, uint8_t *data, int count)
{
(void) stream; (void) data; (void) count;
- assert (0);
+ vlc_assert_unreachable ();
}
httpd_stream_t *httpd_StreamNew (httpd_host_t *host,
{
(void) host; (void) url; (void) content_type;
(void) login; (void) password;
- assert (0);
+ vlc_assert_unreachable ();
}
int httpd_StreamSend (httpd_stream_t *stream, const block_t *p_block)
{
(void) stream; (void) p_block;
- assert (0);
+ vlc_assert_unreachable ();
}
int httpd_StreamSetHTTPHeaders (httpd_stream_t * stream,
size_t i_headers)
{
(void) stream; (void) headers; (void) i_headers;
- assert (0);
+ vlc_assert_unreachable ();
}
int httpd_UrlCatch (httpd_url_t *url, int request, httpd_callback_t cb,
httpd_callback_sys_t *data)
{
(void) url; (void) request; (void) cb; (void) data;
- assert (0);
+ vlc_assert_unreachable ();
}
void httpd_UrlDelete (httpd_url_t *url)
{
(void) url;
- assert (0);
+ vlc_assert_unreachable ();
}
httpd_url_t *httpd_UrlNew (httpd_host_t *host, const char *url,
const char *login, const char *password)
{
(void) host; (void) url; (void) login; (void) password;
- assert (0);
+ vlc_assert_unreachable ();
}
#endif /* !ENABLE_HTTPD */
int sout_AccessOutControl (sout_access_out_t *out, int query, ...)
{
VLC_UNUSED (out); VLC_UNUSED (query);
- assert (0);
+ vlc_assert_unreachable ();
}
void sout_AccessOutDelete (sout_access_out_t *out)
{
VLC_UNUSED (out);
- assert (0);
+ vlc_assert_unreachable ();
}
#undef sout_AccessOutNew
ssize_t sout_AccessOutRead (sout_access_out_t *out, block_t *block)
{
VLC_UNUSED (out); VLC_UNUSED (block);
- assert (0);
+ vlc_assert_unreachable ();
}
int sout_AccessOutSeek (sout_access_out_t *out, off_t offset)
{
VLC_UNUSED (out); VLC_UNUSED (offset);
- assert (0);
+ vlc_assert_unreachable ();
}
ssize_t sout_AccessOutWrite (sout_access_out_t *out, block_t *block)
{
VLC_UNUSED (out); VLC_UNUSED (block);
- assert (0);
+ vlc_assert_unreachable ();
}
#undef sout_AnnounceRegisterSDP
void sout_AnnounceUnRegister (vlc_object_t *obj, session_descriptor_t *d)
{
VLC_UNUSED (obj); VLC_UNUSED (d);
- assert (0);
+ vlc_assert_unreachable ();
}
#undef sout_EncoderCreate
sout_input_t *sout_MuxAddStream (sout_mux_t *mux, es_format_t *fmt)
{
VLC_UNUSED (mux); VLC_UNUSED (fmt);
- assert (0);
+ vlc_assert_unreachable ();
}
void sout_MuxDelete (sout_mux_t *mux)
{
VLC_UNUSED (mux);
- assert (0);
+ vlc_assert_unreachable ();
}
void sout_MuxDeleteStream (sout_mux_t *mux, sout_input_t *input)
{
VLC_UNUSED (mux); VLC_UNUSED (input);
- assert (0);
+ vlc_assert_unreachable ();
}
int sout_MuxGetStream (sout_mux_t *p_mux, unsigned int i_blocks, mtime_t *pi_dts)
{
VLC_UNUSED (p_mux); VLC_UNUSED (i_blocks); VLC_UNUSED (pi_dts);
- assert (0);
+ vlc_assert_unreachable ();
}
sout_mux_t *sout_MuxNew (sout_instance_t *instance, const char *mux,
sout_access_out_t *out)
{
VLC_UNUSED (instance); VLC_UNUSED (mux); VLC_UNUSED (out);
- assert (0);
+ vlc_assert_unreachable ();
}
int sout_MuxSendBuffer (sout_mux_t *mux, sout_input_t *input, block_t *block)
{
VLC_UNUSED (mux); VLC_UNUSED (input); VLC_UNUSED (block);
- assert (0);
+ vlc_assert_unreachable ();
}
void sout_StreamChainDelete (sout_stream_t *p_first, sout_stream_t *p_last)
{
VLC_UNUSED (p_first); VLC_UNUSED (p_last);
- assert (0);
+ vlc_assert_unreachable ();
}
sout_stream_t *sout_StreamChainNew (sout_instance_t *p_sout, char *psz_chain,
{
VLC_UNUSED (p_sout); VLC_UNUSED (psz_chain); VLC_UNUSED (p_next);
VLC_UNUSED (pp_last);
- assert (0);
+ vlc_assert_unreachable ();
}
char *vlc_sdp_Start (vlc_object_t *obj, const char *cfg,
{
VLC_UNUSED (query);
VLC_UNUSED (vlm);
- assert (0);
+ vlc_assert_unreachable ();
}
void vlm_Delete (vlm_t *vlm)
{
VLC_UNUSED (vlm);
- assert (0);
+ vlc_assert_unreachable ();
}
int vlm_ExecuteCommand (vlm_t *vlm, const char *cmd, vlm_message_t **pm)
VLC_UNUSED (vlm);
VLC_UNUSED (cmd);
VLC_UNUSED (pm);
- assert (0);
+ vlc_assert_unreachable ();
}
vlm_message_t *vlm_MessageAdd (vlm_message_t *a, vlm_message_t *b)
{
VLC_UNUSED (a);
VLC_UNUSED (b);
- assert (0);
+ vlc_assert_unreachable ();
}
void vlm_MessageDelete (vlm_message_t *m)
{
VLC_UNUSED (m);
- assert (0);
+ vlc_assert_unreachable ();
}
vlm_message_t *vlm_MessageSimpleNew (const char *a)
break;
}
default:
- assert(0);
+ vlc_assert_unreachable();
}
i_len = 0; /* drop */
}
void vlc_control_cancel (int cmd, ...)
{
(void) cmd;
- assert (0);
+ vlc_assert_unreachable ();
}
/**
}
vlc_cleanup_pop ();
- assert (0);
+ vlc_assert_unreachable ();
}
/**
}
vlc_cleanup_pop ();
- assert (0);
+ vlc_assert_unreachable ();
}
#undef sout_AnnounceRegisterSDP
length += 4;
break;
default:
- assert (0);
+ vlc_assert_unreachable ();
}
/* XXX: Check for dupes */
}
free (str);
}
- assert (0);
+ vlc_assert_unreachable ();
}
static void write_duration(FILE *stream, int64_t duration)
break;
default:
- assert (0);
+ vlc_assert_unreachable ();
}
/* Unrolled continuation bytes decoding */
m.b_double_click = true;
break;
default:
- assert(0);
+ vlc_assert_unreachable();
}
if (is_ignored) {
case VLC_VIDEOS_DIR:
return config_GetShellDir (CSIDL_MYVIDEO);
}
- assert (0);
+ vlc_assert_unreachable ();
}
projects / vlc / commitdiff