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

/** * Load a view file and do lexographical parsing * * Returns pointer to last token, or NULL if an error occured. * If an error occured 'ei' will be filled with data */token_t *glw_view_load1(glw_root_t *gr, rstr_t *url, errorinfo_t *ei, token_t *prev,               int may_unlock){  token_t *last;  char errbuf[256];  rstr_t *p = fa_absolute_path(url, prev->file);  if(may_unlock)    glw_unlock(gr);  buf_t *b = fa_load(rstr_get(p),                     FA_LOAD_VPATHS(gr->gr_vpaths),                     FA_LOAD_ERRBUF(errbuf, sizeof(errbuf)),                     NULL);  if(may_unlock)    glw_lock(gr);  if(b == NULL) {    snprintf(ei->error, sizeof(ei->error), "Unable to open /"%s/" -- %s",	     rstr_get(p), errbuf);    snprintf(ei->file,  sizeof(ei->file),  "%s", rstr_get(prev->file));    ei->line = prev->line;    rstr_release(p);    return NULL;  }  last = glw_view_lexer(gr, buf_cstr(b), ei, p, prev);  buf_release(b);  rstr_release(p);  return last;}

voidjpeg_info_clear(jpeginfo_t *ji){  if(ji->ji_thumbnail != NULL)    pixmap_release(ji->ji_thumbnail);  rstr_release(ji->ji_manufacturer);  rstr_release(ji->ji_equipment);}

static intsidfile_scandir(fa_dir_t *fd, const char *url, char *errbuf, size_t errlen){  void *fh = NULL;  char *p, *fpath = mystrdupa(url);  char buf[128];  char name[32];  char turl[URL_MAX];  int tracks, i;  fa_dir_entry_t *fde;  rstr_t *album, *artist;   if((p = strrchr(fpath, '/')) == NULL) {    snprintf(errbuf, errlen, "Invalid filename");    return -1;  }  *p = 0;  if((fh = fa_open(fpath, errbuf, errlen)) == NULL)    return -1;  if(fa_read(fh, buf, 128) != 128) {    snprintf(errbuf, errlen, "Unable to read file");    fa_close(fh);    return -1;  }  album = rstr_alloc(utf8_from_bytes((char *)buf + 0x16, 32, NULL));  artist = rstr_alloc(utf8_from_bytes((char *)buf + 0x36, 32, NULL));  tracks = buf[0xf];  for(i = 0; i < tracks; i++) {    snprintf(name, sizeof(name), "Track %02d", i + 1);    snprintf(turl, sizeof(turl), "sidplayer:%s/%d", fpath, i + 1);    fde = fa_dir_add(fd, turl, name, CONTENT_AUDIO);    fde->fde_probestatus = FDE_PROBE_DEEP;    fde->fde_metadata = prop_create_root("metadata");    prop_set_string(prop_create(fde->fde_metadata, "title"), name);    prop_set_rstring(prop_create(fde->fde_metadata, "album"), album);    prop_set_rstring(prop_create(fde->fde_metadata, "artist"), artist);  }  rstr_release(album);  rstr_release(artist);  fa_close(fh);  return 0;}

static voidns_val_clr(nls_string_t *ns){  if(ns->ns_values == 1) {    rstr_release(ns->ns_u.rstr);    ns->ns_u.rstr = NULL;  } else if(ns->ns_values > 1) {    int i;    for(i = 0; i < ns->ns_values; i++)      rstr_release(ns->ns_u.vec[i]);    free(ns->ns_u.vec);    ns->ns_u.vec = NULL;  }  ns->ns_values = 0;}

intsearch_class_create(prop_t *parent, prop_t **nodesp, prop_t **entriesp,                    const char *title, const char *icon){    prop_t *p = prop_create_root(NULL);    prop_t *m = prop_create(p, "metadata");    prop_t *n, *e;    rstr_t *url = backend_prop_make(p, NULL);    prop_set_rstring(prop_create(p, "url"), url);    rstr_release(url);    prop_set_string(prop_create(m, "title"), title);    if(icon != NULL)        prop_set_string(prop_create(m, "icon"), icon);    prop_set_string(prop_create(p, "type"), "directory");    n = prop_create(p, "nodes");    e = prop_create(p, "entries");    prop_set_int(e, 0);    *nodesp = prop_ref_inc(n);    *entriesp = prop_ref_inc(e);    if(prop_set_parent(p, parent)) {        prop_destroy(p);        return 1;    }    return 0;}

static intset_path(glw_view_eval_context_t *ec, const token_attrib_t *a,	 struct token *t){  glw_t *w = ec->w;  rstr_t *r;  void (*fn)(glw_t *w, rstr_t *r) = a->fn;  switch(t->type) {  case TOKEN_VOID:    fn(w, NULL);    return 0;  case TOKEN_RSTRING:  case TOKEN_LINK:    r = t->t_rstring;    break;  default:    return glw_view_seterr(ec->ei, t, 			    "Attribute '%s' expects a string or scalar not %s",			   a->name, token2name(t));  }  r = fa_absolute_path(r, t->file);  fn(w, r);  rstr_release(r);  return 0;}

/** * Try to open the given URL with a playqueue context */static intfile_open_audio(prop_t *page, const char *url){  char parent[URL_MAX];  char parent2[URL_MAX];  struct fa_stat fs;  prop_t *model;  if(fa_parent(parent, sizeof(parent), url))    return 1;  if(fa_stat(parent, &fs, NULL, 0))    return 1;    model = prop_create(page, "model");  prop_set_string(prop_create(model, "type"), "directory");  /* Find a meaningful page title (last component of URL) */  rstr_t *title = title_from_url(parent);  prop_setv(model, "metadata", "title", NULL, PROP_SET_RSTRING, title);  // Set parent  if(!fa_parent(parent2, sizeof(parent2), parent))    prop_set_string(prop_create(page, "parent"), parent2);  fa_scanner_page(parent, fs.fs_mtime, model, url,                  prop_create(page, "directClose"), title);  rstr_release(title);  return 0;}

static voidevent_prop_action_dtor(event_t *e){  event_prop_action_t *epa = (event_prop_action_t *)e;  prop_ref_dec(epa->p);  rstr_release(epa->action);}

static rstr_t *ffmpeg_metadata_rstr(AVMetadata *m, const char *key){  AVMetadataTag *tag;  int len;  rstr_t *ret;  const char *str;  char *d;  if((tag = av_metadata_get(m, key, NULL, AV_METADATA_IGNORE_SUFFIX)) == NULL)    return NULL;  if(!utf8_verify(tag->value))    return NULL;  str = tag->value;  len = strlen(str);  ret = rstr_allocl(str, len);  d = rstr_data(ret);  while(len > 0) {    len--;    if(d[len] <= ' ' || d[len] == '-')      d[len] = 0;    else      break;  }  if(*d == 0 || !strncasecmp(d, "http://", 7)) {    rstr_release(ret);    return NULL;  }  return ret;}

static intis_plugin_blacklisted(const char *id, const char *version, rstr_t **reason){  char tmp[512];  int verint = parse_version_int(version);  if(!strcmp(id, "custombg")) {    if(reason != NULL) {      *reason =        _("Custom backgrounds can now be set in Settings -> Look and Feel");    }    return 1;  }  for(int i = 0; i < ARRAYSIZE(blacklist); i++) {    if(strcmp(id, blacklist[i].id))      continue;    if(verint >= blacklist[i].version)      continue;    if(reason != NULL) {      rstr_t *f = _("Version %s is no longer compatible with Movian");      snprintf(tmp, sizeof(tmp), rstr_get(f), version);      rstr_release(f);      *reason = rstr_alloc(tmp);    }    return 1;  }  return 0;}

static intset_alt(glw_view_eval_context_t *ec, const token_attrib_t *a,	struct token *t){  glw_t *w = ec->w;  rstr_t *r;  switch(t->type) {  default:    if(w->glw_class->gc_set_alt != NULL)      w->glw_class->gc_set_alt(w, NULL);    return 0;  case TOKEN_RSTRING:    r = t->t_rstring;    break;  case TOKEN_LINK:    r = t->t_link_rurl;    break;  }  r = fa_absolute_path(r, t->file);  if(w->glw_class->gc_set_alt != NULL)    w->glw_class->gc_set_alt(w, r);  rstr_release(r);  return 0;}

static voidnews_sink(void *opaque, prop_event_t event, ...){  prop_t *p = opaque;  event_t *e;  va_list ap;  va_start(ap, event);  switch(event) {  case PROP_DESTROYED:    prop_unsubscribe(va_arg(ap, prop_sub_t *));    prop_ref_dec(p);    break;  case PROP_EXT_EVENT:    e = va_arg(ap, event_t *);    if(event_is_type(e, EVENT_DYNAMIC_ACTION)) {      const event_payload_t *ep = (const event_payload_t *)e;      if(!strcmp(ep->payload, "dismiss")) {	rstr_t *id = prop_get_string(p, "id", NULL);	dismis_news(rstr_get(id));	rstr_release(id);	prop_destroy(opaque);      }    }    break;  default:    break;  }  va_end(ap);}

static inthc_prop(http_connection_t *hc, const char *remain, void *opaque,        http_cmd_t method){    htsbuf_queue_t out;    rstr_t *r;    int rval, i;    prop_t *p;    const char *action = http_arg_get_req(hc, "action");    if(remain == NULL)        return 404;    p = prop_from_path(remain);    if(p == NULL)        return 404;    htsbuf_queue_init(&out, 0);    switch(method) {    case HTTP_CMD_GET:        if(action != NULL) {            event_t *e = event_create_action_str(action);            prop_send_ext_event(p, e);            event_release(e);            rval = HTTP_STATUS_OK;            break;        }        r = prop_get_string(p, NULL);        if(r == NULL) {            char **childs = prop_get_name_of_childs(p);            if(childs == NULL) {                rval = HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE;                break;            }            for(i = 0; childs[i] != NULL; i++) {                htsbuf_qprintf(&out, "/t%s/n", childs[i]);            }        } else {            htsbuf_append(&out, rstr_get(r), strlen(rstr_get(r)));            htsbuf_append(&out, "/n", 1);            rstr_release(r);        }        rval = http_send_reply(hc, 0, "text/ascii", NULL, NULL, 0, &out);        break;    default:        rval = HTTP_STATUS_METHOD_NOT_ALLOWED;        break;    }    prop_ref_dec(p);    return rval;}

static voidset_source(glw_t *w, rstr_t *filename){  glw_image_t *gi = (glw_image_t *)w;    const rstr_t *curname;  if(gi->gi_pending_url != NULL)    curname = gi->gi_pending_url;  else if(gi->gi_pending != NULL)     curname = gi->gi_pending->glt_url;  else if(gi->gi_current != NULL)     curname = gi->gi_current->glt_url;  else     curname = NULL;    if(curname != NULL && filename != NULL && !strcmp(rstr_get(filename),						    rstr_get(curname)))    return;    if(gi->gi_pending_url != NULL)    rstr_release(gi->gi_pending_url);    gi->gi_pending_url = filename ? rstr_dup(filename) : rstr_alloc("");}

static void callback_opt(void *opaque, prop_event_t event, ...){  setting_t *s = opaque;  prop_callback_string_t *cb;  prop_t *c;  rstr_t *name;  va_list ap;  va_start(ap, event);  cb = s->s_callback;  if(event != PROP_SELECT_CHILD)    return;  c = va_arg(ap, prop_t *);  name = c ? prop_get_name(c) : NULL;  va_end(ap);  if(cb != NULL)    cb(s->s_opaque, rstr_get(name));  if(s->s_store != NULL && s->s_saver != NULL) {    htsmsg_delete_field(s->s_store, s->s_id);    if(name != NULL)      htsmsg_add_str(s->s_store, s->s_id, rstr_get(name));    s->s_saver(s->s_saver_opaque, s->s_store);  }  rstr_release(name);}

static voidnotifications_update(void *opaque, prop_event_t event, ...){  statusbar_t *sb = opaque;  prop_t *p, *txt;  statusbar_entry_t *sbe;  char *buf;  rstr_t *msg;  int i, l;  va_list ap;  va_start(ap, event);  switch(event) {  case PROP_ADD_CHILD:    p = va_arg(ap, prop_t *);    txt = prop_get_by_name(PNVEC("self", "text"), 1,			   PROP_TAG_NAMED_ROOT, p, "self",			   NULL);    if(txt != NULL) {      msg = prop_get_string(txt);      if(msg != NULL) {	buf = mystrdupa(rstr_get(msg));	l = strlen(buf);	for(i = 0; i < l; i++)	  if(buf[i] < ' ')	    buf[i] = ' ';	sbe = calloc(1, sizeof(statusbar_entry_t));	sbe->p = prop_ref_inc(p);	sbe->id = gtk_statusbar_push(GTK_STATUSBAR(sb->bar), sb->ctxid, buf);	LIST_INSERT_HEAD(&sb->entries, sbe, link);	rstr_release(msg);      }      prop_ref_dec(txt);    }    break;  case PROP_DEL_CHILD:    p = va_arg(ap, prop_t *);    LIST_FOREACH(sbe, &sb->entries, link)      if(sbe->p == p)	break;    if(sbe == NULL)      break;    prop_ref_dec(sbe->p);    gtk_statusbar_remove(GTK_STATUSBAR(sb->bar), sb->ctxid, sbe->id);    LIST_REMOVE(sbe, link);    free(sbe);    break;  default:    break;  }}

static voidglw_quad_dtor(glw_t *w){    glw_quad_t *q = (glw_quad_t *)w;    glw_renderer_free(&q->r);    rstr_release(q->fs);    glw_destroy_program(w->glw_root, q->prog);}

voidrstr_vec_free(rstr_vec_t *rv){  int i;  for(i = 0; i < rv->size; i++)    rstr_release(rv->v[i]);  free(rv);}

static voidset_torrent_cache_path(void *opaque, const char *str){  rstr_release(btg.btg_cache_path);  btg.btg_cache_path = rstr_alloc(str);  if(allow_update)    torrent_diskio_scan(0);}

static intset_rstring(glw_view_eval_context_t *ec, const token_attrib_t *a,            struct token *t){  rstr_t *rstr;  char buf[30];  void (*fn)(struct glw *w, rstr_t *str) = a->fn;  switch(t->type) {  case TOKEN_VOID:    buf[0] = 0;    break;  case TOKEN_CSTRING:    rstr = rstr_alloc(t->t_cstring);    fn(ec->w, rstr);    rstr_release(rstr);    return 0;  case TOKEN_RSTRING:  case TOKEN_LINK:    fn(ec->w, t->t_rstring);    return 0;  case TOKEN_INT:    snprintf(buf, sizeof(buf), "%d", t->t_int);    break;  case TOKEN_FLOAT:    snprintf(buf, sizeof(buf), "%f", t->t_float);    break;  default:    return glw_view_seterr(ec->ei, t, 			   "Attribute '%s' expects a string or scalar, got %s",			   a->name, token2name(t));  }  rstr = rstr_alloc(buf);  fn(ec->w, rstr);  rstr_release(rstr);  return 0;}

static voidinput_req_event(void *opaque, event_t *e){  connman_service_t *cs = opaque;  if(cs->cs_input_req_inv == NULL)    return;  if(event_is_action(e, ACTION_OK)) {    rstr_t *username = prop_get_string(cs->cs_input_req_prop, "username", NULL);    rstr_t *password = prop_get_string(cs->cs_input_req_prop, "password", NULL);    GVariant *result;    GVariantBuilder *builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));    g_variant_builder_add(builder, "{sv}", "Passphrase",			  g_variant_new_string(rstr_get(password)));    if(cs->cs_input_req_want_identity)      g_variant_builder_add(builder, "{sv}", "Identity",			    g_variant_new_string(rstr_get(username)));    result = g_variant_new("(a{sv})", builder);    TRACE(TRACE_DEBUG, "CONNMAN", "Auth response: %s",	  g_variant_print(result, TRUE));    g_dbus_method_invocation_return_value(cs->cs_input_req_inv, result);    g_variant_builder_unref(builder);    rstr_release(username);    rstr_release(password);    connman_stop_input_request(cs);  }  if(event_is_action(e, ACTION_CANCEL)) {    g_dbus_method_invocation_return_dbus_error(cs->cs_input_req_inv,					       "net.connman.Agent.Error.Canceled",					       "Canceled by user");    connman_stop_input_request(cs);  }}

void *notify_add(prop_t *root, notify_type_t type, const char *icon, int delay,	   rstr_t *fmt, ...){  char msg[256];  prop_t *p;  const char *typestr;  int tl;  va_list ap, apx;  switch(type) {  case NOTIFY_INFO:    typestr = "info";    tl = TRACE_INFO;  break;  case NOTIFY_WARNING: typestr = "warning"; tl = TRACE_INFO;  break;  case NOTIFY_ERROR:   typestr = "error";   tl = TRACE_ERROR; break;  default: return NULL;  }    va_start(ap, fmt);  va_copy(apx, ap);  tracev(0, tl, "notify", rstr_get(fmt), ap);  vsnprintf(msg, sizeof(msg), rstr_get(fmt), apx);  va_end(ap);  va_end(apx);  rstr_release(fmt);  p = prop_create_root(NULL);  prop_set_string(prop_create(p, "text"), msg);  prop_set_string(prop_create(p, "type"), typestr);  if(icon != NULL)    prop_set_string(prop_create(p, "icon"), icon);  p = prop_ref_inc(p);  if(prop_set_parent(p, root ?: notify_prop_entries))    prop_destroy(p);  if(delay != 0) {    prop_t *r = NULL;    if(delay < 0) {      r = prop_ref_inc(p);      delay = -delay;    }    callout_arm(NULL, notify_timeout, p, delay);    return r;  }  return p;}

intnav_open_errorf(prop_t *root, rstr_t *fmt, ...){  va_list ap;  char buf[200];  va_start(ap, fmt);  vsnprintf(buf, sizeof(buf), rstr_get(fmt), ap);  va_end(ap);  rstr_release(fmt);  return nav_open_error(root, buf);}

static JSBool js_item_bindVideoMetadata(JSContext *cx, JSObject *obj,			  uintN argc, jsval *argv, jsval *rval){  js_item_t *ji = JS_GetPrivate(cx, obj);  JSObject *o = NULL;  rstr_t *title;  if(!JS_ConvertArguments(cx, argc, argv, "o", &o))    return JS_FALSE;    rstr_t *filename = js_prop_rstr(cx, o, "filename");  int year         = js_prop_int_or_default(cx, o, "year", 0);  if(filename != NULL) {    // Raw filename case    title = metadata_remove_postfix_rstr(filename);    rstr_release(filename);    year = -1;  } else {    title = js_prop_rstr(cx, o, "title");  }  int season    = js_prop_int_or_default(cx, o, "season", -1);  int episode   = js_prop_int_or_default(cx, o, "episode", -1);  rstr_t *imdb  = js_prop_rstr(cx, o, "imdb");  int duration  = js_prop_int_or_default(cx, o, "duration", 0);  if(ji->ji_mlv != NULL)    mlv_unbind(ji->ji_mlv, 0);  ji->ji_mlv =    metadata_bind_video_info(ji->ji_url, title, imdb, duration,			     ji->ji_root, NULL, 0, 0, year, season, episode,                             0);  rstr_release(imdb);  rstr_release(title);    *rval = JSVAL_VOID;  return JS_TRUE;}

static voiditem_finalize(JSContext *cx, JSObject *obj){  js_item_t *ji = JS_GetPrivate(cx, obj);  assert(LIST_FIRST(&ji->ji_event_handlers) == NULL);  TAILQ_REMOVE(&ji->ji_model->jm_items, ji, ji_link);  js_model_release(ji->ji_model);  prop_ref_dec(ji->ji_root);  rstr_release(ji->ji_url);  if(ji->ji_mlv != NULL)    mlv_unbind(ji->ji_mlv, 0);  free(ji);}

voidglw_fini(glw_root_t *gr){  glw_text_bitmap_fini(gr);  rstr_release(gr->gr_default_font);  glw_tex_fini(gr);  free(gr->gr_skin);  glw_fini_settings(gr);  pool_destroy(gr->gr_token_pool);  pool_destroy(gr->gr_clone_pool);  prop_courier_destroy(gr->gr_courier);  hts_mutex_destroy(&gr->gr_mutex);}