自学教程：C++ FREENULL函数代码示例

/***************************************************************************** * ParseURL : Split an http:// URL into host, path, and port * * Example: "62.216.251.205:80/protocol_1.2" *      will be split into "62.216.251.205", 80, "protocol_1.2" * * psz_url will be freed before returning * *psz_file & *psz_host will be freed before use * * Return value: *  VLC_ENOMEM      Out Of Memory *  VLC_EGENERIC    Invalid url provided *  VLC_SUCCESS     Success *****************************************************************************/int ParseURL(char* url, char** host, char** path, int* port){  unsigned char port_given = 0,                path_given = 0;  if(url == NULL)    return -1;  FREENULL(*host);  FREENULL(*path);  if(strstr(url, "http://") == url)  {    url = url + 7;  }  size_t port_separator_position = strcspn(url, ":");  size_t path_separator_position = strcspn(url, "/");  if(port_separator_position != strlen(url))  {    port_given = 1;    *host = strndup(url, port_separator_position);    if(*host == NULL)      return VLC_ENOMEM;  }  if(path_separator_position != strlen(url))  {    path_given = 1;    if(!port_given)    {      *host = strndup(url, path_separator_position);      if(*host == NULL)        return VLC_ENOMEM;    }  }  if(port_given)  {    *port = atoi(url + port_separator_position + 1);    *host = strndup(url, port_separator_position);    if(*host == NULL)      return VLC_ENOMEM;  } else {    *port = 80;  }  if(path_given)  {    *path = strdup(url + path_separator_position + 1);  } else {    *path = strdup("/");  }  if(*path == NULL)    return VLC_ENOMEM;  return VLC_SUCCESS;}

/***************************************************************************** * DeleteSong : Delete the char pointers in a song *****************************************************************************/static void DeleteSong(audioscrobbler_song_t* p_song){    FREENULL(p_song->psz_a);    FREENULL(p_song->psz_b);    FREENULL(p_song->psz_t);    FREENULL(p_song->psz_m);    FREENULL(p_song->psz_n);}

void journal_pack( journal_t *journal, char **packed, size_t *size ){	char *packed_journal_header = NULL;	size_t packed_journal_header_size = 0;	char *packed_channel = NULL;	size_t packed_channel_size = 0;	char *packed_channel_buffer = NULL;		size_t packed_channel_buffer_size = 0;	char *p = NULL;	int i = 0;	*packed = NULL;	*size = 0;	if( ! journal ) return;	logging_printf( LOGGING_DEBUG, "journal_pack: journal_has_data = %s header->totchan=%u/n", ( journal_has_data( journal )  ? "YES" : "NO" ) , journal->header->totchan);	if(  ! journal_has_data( journal ) ) return;	journal_header_pack( journal->header, &packed_journal_header, &packed_journal_header_size );	for( i = 0 ; i < MAX_MIDI_CHANNELS ; i++ )	{		if( ! journal->channels[i] ) continue;		channel_pack( journal->channels[i], &packed_channel, &packed_channel_size );		packed_channel_buffer = ( char * )realloc( packed_channel_buffer, packed_channel_buffer_size + packed_channel_size );		if( ! packed_channel_buffer ) goto journal_pack_cleanup;		p = packed_channel_buffer + packed_channel_buffer_size;		memset( p, 0, packed_channel_size );		packed_channel_buffer_size += packed_channel_size;		memcpy( p, packed_channel, packed_channel_size );		FREENULL( "packed_channel", (void **)&packed_channel );	}	// Join it all together	*packed = ( char * )malloc( packed_journal_header_size + packed_channel_buffer_size );	p = *packed;	memcpy( p, packed_journal_header, packed_journal_header_size );	*size += packed_journal_header_size;	p += packed_journal_header_size;	memcpy( p, packed_channel_buffer, packed_channel_buffer_size );	*size += packed_channel_buffer_size;	journal_pack_cleanup:	FREENULL( "packed_channel", (void **)&packed_channel );	FREENULL( "packed_channel_buffer", (void **)&packed_channel_buffer );	FREENULL( "packed_journal_header", (void **)&packed_journal_header );}

void sms_queue_free( sms_queue_t* queue ){    item_t *item = queue->first, *next = NULL;    while( item )    {        next = item->next;        FREENULL( item );        item = next;    }    FREENULL( queue );}

void midi_payload_destroy( midi_payload_t **payload ){	if( ! payload ) return;	if( ! *payload ) return;	(*payload)->buffer = NULL;	if( (*payload)->header )	{		FREENULL( (void **)&((*payload)->header) );	}	FREENULL( (void **)payload );}

/***************************************************************************** * VCDClose: closes VCD releasing allocated memory. *****************************************************************************/voidVCDClose ( vlc_object_t *p_this ){    access_t    *p_access = (access_t *)p_this;    vcdplayer_t *p_vcdplayer = (vcdplayer_t *)p_access->p_sys;    dbg_print( (INPUT_DBG_CALL|INPUT_DBG_EXT), "VCDClose" );    {        unsigned int i;        for (i=0 ; i<p_vcdplayer->i_titles; i++)            if (p_vcdplayer->p_title[i])                free(p_vcdplayer->p_title[i]->psz_name);    }     vcdinfo_close( p_vcdplayer->vcd );    if( p_vcdplayer->p_input ) vlc_object_release( p_vcdplayer->p_input );    FREENULL( p_vcdplayer->p_entries );    FREENULL( p_vcdplayer->p_segments );    FREENULL( p_vcdplayer->psz_source );    FREENULL( p_vcdplayer->track );    FREENULL( p_vcdplayer->segment );    FREENULL( p_vcdplayer->entry );    FREENULL( p_access->psz_demux );    FREENULL( p_vcdplayer );    p_vcd_access    = NULL;}

void config_ChainDestroy( config_chain_t *p_cfg ){    while( p_cfg != NULL )    {        config_chain_t *p_next;        p_next = p_cfg->p_next;        FREENULL( p_cfg->psz_name );        FREENULL( p_cfg->psz_value );        free( p_cfg );        p_cfg = p_next;    }}

/***************************************************************************** * ParseURL : Split an http:// URL into host, file, and port * * Example: "62.216.251.205:80/protocol_1.2" *      will be split into "62.216.251.205", 80, "protocol_1.2" * * psz_url will be freed before returning * *psz_file & *psz_host will be freed before use * * Return value: *  VLC_ENOMEM      Out Of Memory *  VLC_EGENERIC    Invalid url provided *  VLC_SUCCESS     Success *****************************************************************************/static int ParseURL( char *psz_url, char **psz_host, char **psz_file,                        int *i_port ){    int i_pos;    int i_len = strlen( psz_url );    bool b_no_port = false;    FREENULL( *psz_host );    FREENULL( *psz_file );    i_pos = strcspn( psz_url, ":" );    if( i_pos == i_len )    {        *i_port = 80;        i_pos = strcspn( psz_url, "/" );        b_no_port = true;    }    *psz_host = strndup( psz_url, i_pos );    if( !*psz_host )        return VLC_ENOMEM;    if( !b_no_port )    {        i_pos++; /* skip the ':' */        *i_port = atoi( psz_url + i_pos );        if( *i_port <= 0 )        {            FREENULL( *psz_host );            return VLC_EGENERIC;        }        i_pos = strcspn( psz_url, "/" );    }    if( i_pos == i_len )        return VLC_EGENERIC;    i_pos++; /* skip the '/' */    *psz_file = strdup( psz_url + i_pos );    if( !*psz_file )    {        FREENULL( *psz_host );        return VLC_ENOMEM;    }    free( psz_url );    return VLC_SUCCESS;}

int sms_queue_put( sms_queue_t *queue, const uint64_t value ){    /* Remove the last (and oldest) item */    item_t *item, *prev = NULL;    int count = 0;    for( item = queue->first; item != NULL; item = item->next )    {        count++;        if( count == queue->length )        {            FREENULL( item );            if( prev ) prev->next = NULL;            break;        }        else            prev = item;    }    /* Now insert the new item */    item_t *_new = (item_t *)malloc( sizeof( item_t ) );			// sunqueen modify    if( unlikely( !_new ) )			// sunqueen modify        return VLC_ENOMEM;    _new->value = value;			// sunqueen modify    _new->next = queue->first;			// sunqueen modify    queue->first = _new;			// sunqueen modify    return VLC_SUCCESS;}

bool cDVDList::Create(char *dir, char *exts, char *dirs, eFileList smode, bool sub){  MYDEBUG("DVDList: %s, %s", exts, dirs);  Clear();  FREENULL(DVDExts);  FREENULL(DVDDirs);  DVDExts = exts ? strdup(exts) : NULL;  DVDDirs = dirs ? strdup(dirs) : NULL;  if(!DVDExts && !DVDDirs)    return false;  return Load(dir, smode, sub);}

void channel_destroy( channel_t **channel ){	if( ! channel ) return;	if( ! *channel ) return;	if( (*channel)->chapter_n )	{		chapter_n_destroy( &( (*channel)->chapter_n ) );	}	if( (*channel)->chapter_c )	{		chapter_c_destroy( &( (*channel)->chapter_c ) );	}	if( (*channel)->chapter_p )	{		chapter_p_destroy( &( (*channel)->chapter_p ) );	}	if( (*channel)->header )	{		channel_header_destroy( &( (*channel)->header ) );	}	FREENULL("channel", (void **) channel);}

static chunk_t * gotoNextChunk( stream_sys_t *p_sys ){    assert(p_sys->p_current_stream);    chunk_t *p_prev = p_sys->p_current_stream->p_playback;    if ( p_prev )    {        if ( p_sys->b_live )        {            /* Discard chunk and update stream pointers */            assert( p_sys->p_current_stream->p_chunks ==  p_sys->p_current_stream->p_playback );            p_sys->p_current_stream->p_playback = p_sys->p_current_stream->p_playback->p_next;            p_sys->p_current_stream->p_chunks = p_sys->p_current_stream->p_chunks->p_next;            if ( p_sys->p_current_stream->p_lastchunk == p_prev )                p_sys->p_current_stream->p_lastchunk = NULL;            chunk_Free( p_prev );        }        else        {            /* Just cleanup chunk for reuse on seek */            p_sys->p_current_stream->p_playback = p_sys->p_current_stream->p_playback->p_next;            FREENULL(p_prev->data);            p_prev->read_pos = 0;            p_prev->offset = CHUNK_OFFSET_UNSET;            p_prev->size = 0;        }    }    /* Select new current pointer among streams playback heads */    p_sys->p_current_stream = next_playback_stream( p_sys );    if ( !p_sys->p_current_stream )        return NULL;    return p_sys->p_current_stream->p_playback;}

char *cFileInfo::FileNameWithoutExt(void){  char *ext = NULL;  char *filename = NULL;    if(Extension())     ext = strdup(Extension());  if(FileName())    filename = strdup(FileName());  FREENULL(buffer);    if(ext && filename)  {    int len = strlen(filename) - strlen(ext) + 1;    buffer = (char*)malloc(len);    strn0cpy(buffer, filename, len);  }  else if(filename)    buffer = strdup(filename);  free(ext);  free(filename);  MYDEBUG("FileInfo: FileNameWithoutExt: %s", buffer);  return buffer;}

bool cFileList::Read(char *dir, bool withsub){  bool ret = false;  char *buffer = NULL;  struct dirent *DirData = NULL;  cReadDir Dir(dir);  if(Dir.Ok())  {    while((DirData = Dir.Next()) != NULL)    {      if(CheckIncludes(dir, DirData->d_name)  &&         !CheckExcludes(dir, DirData->d_name) &&         CheckType(dir, DirData->d_name, Type))        SortIn(dir, DirData->d_name);      if(withsub &&         CheckType(dir, DirData->d_name, tDir) &&         !RegIMatch(DirData->d_name, "^//.{1,2}$"))      {        asprintf(&buffer, "%s/%s", dir, DirData->d_name);        Read(buffer, withsub);        FREENULL(buffer);      }    }    ret = true;  }  return ret;}

/* <genrelist> *   <genre name="the name"></genre> *   ... * </genrelist> **/static int DemuxGenre( demux_t *p_demux, xml_reader_t *p_xml_reader,                       input_item_node_t *p_input_node ){    const char *node;    char *psz_name = NULL; /* genre name */    int type;    while( (type = xml_ReaderNextNode( p_xml_reader, &node )) > 0 )    {        switch( type )        {            case XML_READER_STARTELEM:            {                if( !strcmp( node, "genre" ) )                {                    // Read the attributes                    const char *name, *value;                    while( (name = xml_ReaderNextAttr( p_xml_reader, &value )) )                    {                        if( !strcmp( name, "name" ) )                        {                            free(psz_name);                            psz_name = strdup( value );                        }                        else                            msg_Warn( p_demux,                                      "unexpected attribute %s in <%s>",                                      name, node );                    }                }                break;            }            case XML_READER_ENDELEM:                if( !strcmp( node, "genre" ) && psz_name != NULL )                {                    char* psz_mrl;                    if( asprintf( &psz_mrl, SHOUTCAST_BASE_URL "?genre=%s",                                  psz_name ) != -1 )                    {                        input_item_t *p_input;                        vlc_xml_decode( psz_mrl );                        p_input = input_item_New( psz_mrl, psz_name );                        input_item_CopyOptions( p_input_node->p_item, p_input );                        free( psz_mrl );                        input_item_node_AppendItem( p_input_node, p_input );                        vlc_gc_decref( p_input );                    }                    FREENULL( psz_name );                }                break;        }    }    free( psz_name );    return 0;}

void http_auth_Reset( http_auth_t *p_auth ){    p_auth->i_nonce = 0;    FREENULL( p_auth->psz_realm );    FREENULL( p_auth->psz_domain );    FREENULL( p_auth->psz_nonce );    FREENULL( p_auth->psz_opaque );    FREENULL( p_auth->psz_stale );    FREENULL( p_auth->psz_algorithm );    FREENULL( p_auth->psz_qop );    FREENULL( p_auth->psz_cnonce );    FREENULL( p_auth->psz_HA1 );}

static void cleanup_attributes(custom_attrs_t **cp){    if( !*cp )        return;    free( (*cp)->psz_key );    free( (*cp)->psz_value );    FREENULL( *cp );}

static void Run( fingerprinter_thread_t *p_fingerprinter ){    fingerprinter_sys_t *p_sys = p_fingerprinter->p_sys;    /* main loop */    for (;;)    {        vlc_mutex_lock( &p_sys->processing.lock );        mutex_cleanup_push( &p_sys->processing.lock );        vlc_cond_timedwait( &p_sys->incoming_queue_filled, &p_sys->processing.lock, mdate() + 1000000 );        vlc_cleanup_run();        QueueIncomingRequests( p_sys );        vlc_mutex_lock( &p_sys->processing.lock ); // L0        mutex_cleanup_push( &p_sys->processing.lock );        vlc_cleanup_push( cancelRun, p_sys ); // C1//**        for ( p_sys->i = 0 ; p_sys->i < vlc_array_count( p_sys->processing.queue ); p_sys->i++ )        {            fingerprint_request_t *p_data = vlc_array_item_at_index( p_sys->processing.queue, p_sys->i );            acoustid_fingerprint_t acoustid_print;            memset( &acoustid_print , 0, sizeof(acoustid_fingerprint_t) );            vlc_cleanup_push( clearPrint, &acoustid_print ); // C2            p_sys->psz_uri = input_item_GetURI( p_data->p_item );            if ( p_sys->psz_uri )            {                /* overwrite with hint, as in this case, fingerprint's session will be truncated */                if ( p_data->i_duration ) acoustid_print.i_duration = p_data->i_duration;                DoFingerprint( VLC_OBJECT(p_fingerprinter), p_sys, &acoustid_print );                DoAcoustIdWebRequest( VLC_OBJECT(p_fingerprinter), &acoustid_print );                fill_metas_with_results( p_data, &acoustid_print );                FREENULL( p_sys->psz_uri );            }            vlc_cleanup_run( ); // C2            /* copy results */            vlc_mutex_lock( &p_sys->results.lock );            vlc_array_append( p_sys->results.queue, p_data );            vlc_mutex_unlock( &p_sys->results.lock );            vlc_testcancel();        }        if ( vlc_array_count( p_sys->processing.queue ) )        {            var_TriggerCallback( p_fingerprinter, "results-available" );            vlc_array_clear( p_sys->processing.queue );        }        vlc_cleanup_pop( ); // C1//**        vlc_cleanup_run(); // L0    }}

static http_cookie_t *cookie_parse(const char *value,                                   const char *host, const char *path){    http_cookie_t *cookie = calloc( 1, sizeof( http_cookie_t ) );    if ( unlikely( !cookie ) )        return NULL;    char *content = cookie_get_content(value);    if ( !content )    {        cookie_destroy( cookie );        return NULL;    }    const char *eq = strchr( content, '=' );    if ( eq )    {        cookie->psz_name = strndup( content, eq-content );        cookie->psz_value = strdup( eq + 1 );    }    else    {        cookie->psz_name = strdup( content );        cookie->psz_value = NULL;    }    cookie->psz_domain = cookie_get_domain(value);    if ( !cookie->psz_domain || strlen(cookie->psz_domain) == 0 )    {        free(cookie->psz_domain);        cookie->psz_domain = strdup(host);        cookie->b_host_only = true;    }    else        cookie->b_host_only = false;    cookie->psz_path = cookie_get_attribute_value(value, "path" );    if ( !cookie->psz_path || strlen(cookie->psz_path) == 0 )    {        free(cookie->psz_path);        cookie->psz_path = cookie_default_path(path);    }    cookie->b_secure = cookie_has_attribute(value, "secure" );    FREENULL( content );    if ( !cookie->psz_domain || !cookie->psz_path || !cookie->psz_name )    {        cookie_destroy( cookie );        return NULL;    }    return cookie;}

/***************************************************************************** * Called through lua_scripts_batch_execute to call 'probe' on * the script pointed by psz_filename. *****************************************************************************/static int probe_luascript( vlc_object_t *p_this, const char * psz_filename,                            lua_State * L, void * user_data ){    VLC_UNUSED(user_data);    demux_t * p_demux = (demux_t *)p_this;    p_demux->p_sys->psz_filename = strdup(psz_filename);    /* In lua, setting a variable's value to nil is equivalent to deleting it */    lua_pushnil( L );    lua_pushnil( L );    lua_setglobal( L, "probe" );    lua_setglobal( L, "parse" );    /* Load and run the script(s) */    if( luaL_dofile( L, psz_filename ) )    {        msg_Warn( p_demux, "Error loading script %s: %s", psz_filename,                  lua_tostring( L, lua_gettop( L ) ) );        goto error;    }    lua_getglobal( L, "probe" );    if( !lua_isfunction( L, -1 ) )    {        msg_Warn( p_demux, "Error while runing script %s, "                  "function probe() not found", psz_filename );        goto error;    }    if( lua_pcall( L, 0, 1, 0 ) )    {        msg_Warn( p_demux, "Error while runing script %s, "                  "function probe(): %s", psz_filename,                  lua_tostring( L, lua_gettop( L ) ) );        goto error;    }    if( lua_gettop( L ) )    {        if( lua_toboolean( L, 1 ) )        {            msg_Dbg( p_demux, "Lua playlist script %s's "                     "probe() function was successful", psz_filename );            lua_pop( L, 1 );            return VLC_SUCCESS;        }    }error:    lua_pop( L, 1 );    FREENULL( p_demux->p_sys->psz_filename );    return VLC_EGENERIC;}

/***************************************************************************** * sout_NewInstance: creates a new stream output instance *****************************************************************************/sout_instance_t *sout_NewInstance( vlc_object_t *p_parent, const char *psz_dest ){    sout_instance_t *p_sout;    char *psz_chain;    assert( psz_dest != NULL );    if( psz_dest[0] == '#' )    {        psz_chain = strdup( &psz_dest[1] );    }    else    {        psz_chain = sout_stream_url_to_chain(            var_InheritBool(p_parent, "sout-display"), psz_dest );    }    if(!psz_chain)        return NULL;    /* *** Allocate descriptor *** */    p_sout = vlc_custom_create( p_parent, sizeof( *p_sout ), "stream output" );    if( p_sout == NULL )    {        free( psz_chain );        return NULL;    }    msg_Dbg( p_sout, "using sout chain=`%s'", psz_chain );    /* *** init descriptor *** */    p_sout->psz_sout    = strdup( psz_dest );    p_sout->i_out_pace_nocontrol = 0;    vlc_mutex_init( &p_sout->lock );    p_sout->p_stream = NULL;    var_Create( p_sout, "sout-mux-caching", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );    p_sout->p_stream = sout_StreamChainNew( p_sout, psz_chain, NULL, NULL );    if( p_sout->p_stream )    {        free( psz_chain );        return p_sout;    }    msg_Err( p_sout, "stream chain failed for `%s'", psz_chain );    free( psz_chain );    FREENULL( p_sout->psz_sout );    vlc_mutex_destroy( &p_sout->lock );    vlc_object_release( p_sout );    return NULL;}

char* cCMDImage::Rename(char *file){  MYDEBUG("CMDImage Rename");  if(file)  {    FREENULL(File);    File = strdup(file);  }  return File;}

eOSState cCMDDir::New(eKeys Key){  switch(Key)  {    case kOk:      if(!isempty(Dir))      {        char *buffer = NULL;        asprintf(&buffer, "%s/%s", CurrentDir(), stripspace(Dir));        MYDEBUG("Verzeichnis: Neu: Anlegen: %s", buffer);        cFileInfo *info = new cFileInfo(buffer);        if(info->isExists())        {          MYDEBUG("Verzeichnis existiert bereits");          OSD_WARNMSG(tr("Directory exists"));          FREENULL(buffer);          DELETENULL(info);          return osContinue;        }        if(cFileCMD::Mkdir(buffer))        {          MYDEBUG("Verzeichnis anlegen erfolgreich");          LastSelDir(buffer);          if(!Select)            OsdObject->SetState(mmsReInit);        }        FREENULL(buffer);        DELETENULL(info);      }    case kBack:      State = csNone;      Build();      return osContinue;      break;    default:      break;  }  return cOsdMenu::ProcessKey(Key);}

/***************************************************************************** * sout_DeleteInstance: delete a previously allocated instance *****************************************************************************/void sout_DeleteInstance( sout_instance_t * p_sout ){    /* remove the stream out chain */    sout_StreamChainDelete( p_sout->p_stream, NULL );    /* *** free all string *** */    FREENULL( p_sout->psz_sout );    vlc_mutex_destroy( &p_sout->lock );    /* *** free structure *** */    vlc_object_release( p_sout );}

/* Destroy a "stream_out" module */static void sout_StreamDelete( sout_stream_t *p_stream ){    msg_Dbg( p_stream, "destroying chain... (name=%s)", p_stream->psz_name );    if( p_stream->p_module ) module_unneed( p_stream, p_stream->p_module );    FREENULL( p_stream->psz_name );    config_ChainDestroy( p_stream->p_cfg );    msg_Dbg( p_stream, "destroying chain done" );    vlc_object_release( p_stream );}

static void cancelDoFingerprint( void *p_arg ){    fingerprinter_sys_t *p_sys = ( fingerprinter_sys_t * ) p_arg;    if ( p_sys->p_input )    {        input_Stop( p_sys->p_input, true );        input_Close( p_sys->p_input );    }    /* cleanup temporary result */    if ( p_sys->chroma_fingerprint.psz_fingerprint )        FREENULL( p_sys->chroma_fingerprint.psz_fingerprint );    if ( p_sys->p_item )        input_item_Release( p_sys->p_item );}