int users_search(mongo* conn, User* users, int limit) { int pos = 0; mongo_cursor cursor[1]; bson_iterator iterator[1]; mongo_cursor_init(cursor, conn, "ruby-mongo-console.users"); // mongo_cursor_set_query mongo_cursor_set_limit(cursor, limit); while(mongo_cursor_next(cursor) == MONGO_OK) { const char* s; s = get_field_value(iterator, cursor, "name"); if (s) { users[pos].name_len = strlen(s); users[pos].name = new_str(s, users[pos].name_len); } else { users[pos].name_len = 0; users[pos].name = NULL; } s = get_field_value(iterator, cursor, "bio"); if (s) { users[pos].bio_len = strlen(s); users[pos].bio = new_str(s, users[pos].bio_len); } else { users[pos].bio_len = 0; users[pos].bio = NULL; } pos++; } mongo_cursor_destroy(cursor); return pos; }
void int_update_driver_data(hd_data_t *hd_data, hd_t *hd) { hd_sysfsdrv_t *sf; str_list_t *sl; hd->driver_modules = free_str_list(hd->driver_modules); for(sl = hd->drivers; sl; sl = sl->next) { for(sf = hd_data->sysfsdrv; sf; sf = sf->next) { if(sf->module && !strcmp(sf->driver, sl->str)) { add_str_list(&hd->driver_modules, sf->module); } } } hd->driver = free_mem(hd->driver); hd->driver_module = free_mem(hd->driver_module); if(hd->drivers && hd->drivers->str) { hd->driver = new_str(hd->drivers->str); for(sf = hd_data->sysfsdrv; sf; sf = sf->next) { if(sf->module && !strcmp(sf->driver, hd->driver)) { hd->driver_module = new_str(sf->module); } } } }
void tex::end_name () { int n; if (area_str == null_str) { cur_area = null_str; area_str = name_of_file; } else { n = area_str - name_of_file; cur_area = new_str(n); strncpy(cur_area, name_of_file, n); } if (ext_str == null_str) { cur_ext = null_str; ext_str = name_str; } else { n = name_str - ext_str; cur_ext = new_str(n); strncpy(cur_ext, ext_str, n); } n = ext_str - area_str; if (n == 0) { cur_name = null_str; } else { cur_name = new_str(n); strncpy(cur_name, area_str, n); } }
SpecialFolderItem::SpecialFolderItem(LPCTSTR pszTitle, const TCHAR *pszPath, struct pidl_node* pidl_list, const TCHAR *optional_command, const TCHAR* pszIcon) : FolderItem(NULL, pszTitle, NULL) { m_pidl_list = pidl_list; m_ItemID = MENUITEM_ID_SF; m_pszPath = new_str(pszPath); // command to apply to files, optional m_pszExtra = new_str(optional_command); m_phIcon = GetIcon(pszIcon); }
/* * Go through serial mouse data and add hd entries. */ void add_serial_mouse(hd_data_t *hd_data) { hd_t *hd; char buf[4]; ser_device_t *sm; for(sm = hd_data->ser_mouse; sm; sm = sm->next) { if(sm->is_mouse) { hd = add_hd_entry(hd_data, __LINE__, 0); hd->base_class.id = bc_mouse; hd->sub_class.id = sc_mou_ser; hd->bus.id = bus_serial; hd->unix_dev_name = new_str(sm->dev_name); hd->attached_to = sm->hd_idx; if(*sm->pnp_id) { strncpy(buf, sm->pnp_id, 3); buf[3] = 0; hd->vendor.id = name2eisa_id(buf); if(!hd->vendor.id) { /* in case it's a really strange one... */ hd->vendor.name = new_str(buf); } hd->device.id = MAKE_ID(TAG_EISA, strtol(sm->pnp_id + 3, NULL, 16)); hd->serial = new_str(sm->serial); if(sm->user_name) hd->device.name = new_str(sm->user_name); if(sm->vend) { free_mem(hd->vendor.name); hd->vendor.name = new_str(sm->vend); } if(sm->dev_id && strlen(sm->dev_id) >= 7) { char buf[5], *s; unsigned u1, u2; u1 = name2eisa_id(sm->dev_id); if(u1) { strncpy(buf, sm->dev_id + 3, 4); buf[4] = 0; u2 = strtol(sm->dev_id + 3, &s, 16); if(!*s) { hd->compat_vendor.id = u1; hd->compat_device.id = MAKE_ID(TAG_EISA, u2); } } } } else { hd->vendor.id = MAKE_ID(TAG_SPECIAL, 0x0200); hd->device.id = MAKE_ID(TAG_SPECIAL, 0x0003); } } } }
char* exec_cmd(char* cmd, t_client* client, t_data* data) { char* res; char** parse; parse = cut_cmd(data, cmd); if (channel(parse, client, data) == 1) return (NULL); else if (strcmp(parse[0], "/nick") == 0) return (nickname(data, client, parse)); else if (strcmp(parse[0], "/quit") == 0) return (quit(data, client)); else if (strcmp(parse[0], "/msg") == 0) return (msg_private(data, client, parse)); else if (strcmp(parse[0], "/server") == 0) return (quit(data, client)); else if (strcmp(parse[0], "/send_file") == 0) return (NULL); else if (strcmp(parse[0], "/accept_file") == 0) return (NULL); else if (parse[0][0] != '/') return (msg_general(data, client, parse)); else return (new_str(NULL, strcat(parse[0], " : command not found"), data)); return (res); }
/* Allocates memory */ string* factor_vm::reallot_string(string* str_, cell capacity) { data_root<string> str(str_, this); if (reallot_string_in_place_p(str.untagged(), capacity)) { str->length = tag_fixnum(capacity); if (to_boolean(str->aux)) { byte_array* aux = untag<byte_array>(str->aux); aux->capacity = tag_fixnum(capacity * 2); } return str.untagged(); } else { cell to_copy = string_capacity(str.untagged()); if (capacity < to_copy) to_copy = capacity; data_root<string> new_str(allot_string_internal(capacity), this); memcpy(new_str->data(), str->data(), to_copy); if (to_boolean(str->aux)) { byte_array* new_aux = allot_uninitialized_array<byte_array>(capacity * 2); new_str->aux = tag<byte_array>(new_aux); write_barrier(&new_str->aux); byte_array* aux = untag<byte_array>(str->aux); memcpy(new_aux->data<uint16_t>(), aux->data<uint16_t>(), to_copy * sizeof(uint16_t)); } fill_string(new_str.untagged(), to_copy, capacity, '\0'); return new_str.untagged(); } }
str _(const char* fmt, ...) { va_list args; va_start(args,fmt); return new_str(fmt,args); }
int main(int argc, char **argv) { Subst subst; message_setseverity(MSG_NOTICE | MSG_ERR); subst_construct(&subst); /* construct the Subst object */ subst_insert(&subst, "DEMO", "one", "ONE SUBST"); subst_insert(&subst, "DEMO", "one", "TWO SUBST"); subst_insert(&subst, "DEMO", "\\'e", "é"); while (true) { char *cp; puts("Enter text: "); if (!fgets(buffer, 80, stdin) || buffer[0] == '\n') break; for (cp = buffer; *cp && *cp != '\n'; cp++) { printf("Inspecting char `%c': ", *cp); if (subst_find(&subst, *cp)) printf("found. Swallowed by subst\n"); else { char *txt = new_str(subst_text(&subst)); printf("Not found. Next returned: `%c(`%s')\n", subst_get(&subst), txt ? txt : ""); free(txt); } } } }
char const *s_state_insert(register State *sp, char const *key, char const *subst) { while (*key) { register char const *cp; /* if key is in the set, switch to */ if ((cp = strchr(sp->d_str, *key)) != 0) /* that state */ sp = sp->d_next[cp - sp->d_str]; else { /* if not, add a new state to the */ size_t last = string_length(&sp->d_set); /* set */ string_addchar(&sp->d_set, (char)*key); /* add key's 1st char */ sp->d_str = string_str(&sp->d_set); /* and set the state's ptr */ /* add a new state */ new_size(&sp->d_next, last + 1, last, sizeof(State *)); sp = sp->d_next[last] = s_state_new(); } key++; /* inspect the next key char */ } /* all key chars exhausted: insert */ /* replacement text */ if (sp->d_replacement) /* oops, it's already there */ return sp->d_replacement; /* return the one found */ sp->d_replacement = new_str(subst); return 0; /* here 0 indicates SUCCESS */ }
void int_bios(hd_data_t *hd_data) { hd_t *hd, *hd_boot; int i, start, bios = 0x80; int ide_1st; char ide_name[] = "/dev/hda"; char scsi_name[] = "/dev/sda"; char *s; hd_boot = hd_get_device_by_idx(hd_data, hd_boot_disk(hd_data, &i)); if(hd_boot) { free_mem(hd_boot->rom_id); hd_boot->rom_id = new_str("0x80"); } if(!hd_boot || i != 1) return; if(strstr(hd_boot->unix_dev_name, "/dev/sd") == hd_boot->unix_dev_name) { ide_1st = 0; start = hd_boot->unix_dev_name[sizeof "/dev/sd" - 1] - 'a'; } else if(strstr(hd_boot->unix_dev_name, "/dev/hd") == hd_boot->unix_dev_name) { ide_1st = 1; start = hd_boot->unix_dev_name[sizeof "/dev/hd" - 1] - 'a'; } else { return; } if(start < 0) return; for(hd = hd_data->hd; hd; hd = hd->next) { if( hd->base_class.id == bc_storage_device && hd->sub_class.id == sc_sdev_disk ) { hd->rom_id = free_mem(hd->rom_id); } } s = ide_1st ? ide_name : scsi_name; for(i = start; i < 26; i++) { s[strlen(s) - 1] = 'a' + i; bios += set_bios_id(hd_data, s, bios); } for(i = 0; i < start; i++) { s[strlen(s) - 1] = 'a' + i; bios += set_bios_id(hd_data, s, bios); } s = ide_1st ? scsi_name : ide_name; for(i = 0; i < 26; i++) { s[strlen(s) - 1] = 'a' + i; bios += set_bios_id(hd_data, s, bios); } }
MenuItem::MenuItem(const char* pszTitle) { next = NULL; m_pMenu = m_pSubMenu = NULL; m_nWidth = m_nHeight = 0; m_isNOP = m_bActive = m_isChecked = false; m_nSortPriority = M_SORT_NORMAL; m_ItemID = MENUITEM_ID_NORMAL; m_pszTitle = new_str(pszTitle); m_pszCommand = NULL; m_pidl = NULL; m_hIcon = NULL; m_iconMode = IM_NONE; ++g_menu_item_count; }
HashItem *construct_preset(char const *setkey, char *rest) { char *key; HashItem *mapItem; if (!(key = string_firstword(&rest))) /* get the key */ { /* e.g., title */ message_error("`preset ...: missing key"); return 0; } if (strcmp(key, "nohtmlfive") == 0) global.d_html5 = 0; else { if (!*string_strip(&rest)) /* get the value */ warning("Empty value of symbol `%s'", key); /* e.g., This is... */ if (strcmp(key, "styleopt") == 0) /* store styleopts */ lines_add(&global.d_styleopt, rest); else { /* look up the key */ mapItem = hashmap_find(&global.d_symbol, key, ANY); if (mapItem != PFAILED) /* reassign */ hashitem_set(mapItem, rest, free); /* existing value */ else /* or insert new */ hashmap_insert(&global.d_symbol, /* element */ hashitem_construct(VOIDPTR, key, new_str(rest), free)); } } free(key); return hashitem_construct(VOIDPTR, "", 0, root_nop); }
static int loop(t_str *str, t_hist *historic,\ char **line, int success) { int i; while (success && str) { i = -1; while (str->str[++i] && str->str[i] != '\n' && str->str[i] != '\r') ; if (str->str[i] == '\n' || str->str[i] == '\r') { while (str->str[i] == '\n') str->str[i++] = '\0'; historic->garbage = &str->str[i]; return (achievement(historic, line)); } str->next = new_str(); str = str->next; str->str = (char *)malloc(sizeof(char) * BUFF_SIZE + 1); ft_bzero(str->str, BUFF_SIZE + 1); success = read(historic->fd, str->str, BUFF_SIZE); } return (0); }
CommandItem::CommandItem(const char* pszCommand, const char* pszTitle, bool bChecked) : MenuItem(pszTitle) { m_pszCommand = new_str(pszCommand); m_bChecked = bChecked; m_ItemID = MENUITEM_ID_CMD; }
/* * Check if str has str2 in it. */ int contains_word(char *str, char *str2) { int i, len, len2, found = 0; char *s; if(!str2 || !*str2 || !str || !*str) return 0; str = new_str(str); len = strlen(str); len2 = strlen(str2); for(i = 0; i < len; i++) { if(str[i] >= 'a' && str[i] <= 'z') str[i] -= 'a' - 'A'; } for(s = str; (s = strstr(s, str2)); s++) { if( (s == str || s[-1] < 'A' || s[-1] > 'Z') && (s[len2] < 'A' || s[len2] > 'Z') ) { found = 1; break; } } free_mem(str); return found; }
_menuitemint(n_menu *m, const char *_text, const char *_cmd, int _initval, int _minval, int _maxval) : _menuitem(m, _text, i_int) { cmd = new_str(_cmd); initval = _initval; minval = _minval; maxval = _maxval; }
_menuitem(n_menu *m, const char *_text, int _mode) { mode = _mode; text = new_str(_text); next = NULL; disabled = false; m->additem(this); }
str tex::make_name_str() { str s; s = new_str(name_length); strcpy(s, name_of_file); return (s); }
Str *str_concat(Str *a, Str *b) { Str *out = (Str*)new_str(); for(int i = 0; i < a->size; i++) str_append(out, a->array[i]); for(int i = 0; i < b->size; i++) str_append(out, b->array[i]); return out; }
FolderItem::FolderItem(Menu* pSubMenu, const char* pszTitle, const char* pszIcon) : MenuItem(pszTitle) { m_nSortPriority = M_SORT_FOLDER; m_ItemID = MENUITEM_ID_FOLDER; LinkSubmenu(pSubMenu); m_pszIcon = new_str(pszIcon); GetIcon(); }
/* * Add udev info. */ void int_udev(hd_data_t *hd_data) { hd_udevinfo_t *ui; hd_t *hd; str_list_t *sl; if(!hd_data->udevinfo) read_udevinfo(hd_data); if(!hd_data->udevinfo) return; for(hd = hd_data->hd; hd; hd = hd->next) { if(!hd->unix_dev_names && hd->unix_dev_name) { add_str_list(&hd->unix_dev_names, hd->unix_dev_name); } if(!hd->sysfs_id) continue; for(ui = hd_data->udevinfo; ui; ui = ui->next) { if(ui->name && !strcmp(ui->sysfs, hd->sysfs_id)) { if(!search_str_list(hd->unix_dev_names, ui->name)) { add_str_list(&hd->unix_dev_names, ui->name); } for(sl = ui->links; sl; sl = sl->next) { if(!search_str_list(hd->unix_dev_names, sl->str)) { add_str_list(&hd->unix_dev_names, sl->str); } } if(!hd->unix_dev_name || hd_data->flags.udev) { sl = hd->unix_dev_names; if(hd_data->flags.udev) { /* use first link as canonical device name */ if(ui->links) sl = sl->next; } hd->unix_dev_name = new_str(sl->str); } break; } } } for(hd = hd_data->hd; hd; hd = hd->next) { if(!hd->unix_dev_names) continue; for(ui = hd_data->udevinfo; ui; ui = ui->next) { if(search_str_list(hd->unix_dev_names, ui->name)) { for(sl = ui->links; sl; sl = sl->next) { if(!search_str_list(hd->unix_dev_names, sl->str)) { add_str_list(&hd->unix_dev_names, sl->str); } } } } } }
//================================================ void SpecialFolder::UpdateFolder(void) { // --------------------------------------- // remember the active item as text MenuItem *ActiveItem = m_pActiveItem; TCHAR *active_item_text = NULL; m_pLastChild = m_pChild; if (m_pLastChild) ActiveItem = m_pLastChild->m_pParentItem; if (ActiveItem) active_item_text = new_str(ActiveItem->m_pszTitle); // delete_old items DeleteMenuItems(); // load the folder contents MenuItem *Items = NULL; int r = 0; struct pidl_node *p; dolist (p, m_pidl_list) r |= MenuMaker_LoadFolder(&Items, p->v, m_pszExtra); if (Items) add_folder_contents(Items, NULL != m_pidl_list->next); else if (r) MakeMenuNOP(this, NLS0(_T("No Files"))); else MakeMenuNOP(this, NLS0(_T("Invalid Path"))); // --------------------------------------- // search by text the previously active item if (active_item_text) { dolist (ActiveItem, m_pMenuItems) if (0 == _tcscmp(active_item_text, ActiveItem->m_pszTitle)) break; free_str(&active_item_text); } // --------------------------------------- // possibly reconnect to an open child-folder if (m_pLastChild) { if (ActiveItem) { m_pLastChild->incref(); ActiveItem->LinkSubmenu(m_pLastChild); m_pLastChild->LinkToParentItem(ActiveItem); } else { m_pLastChild->Hide(); // lost child } m_pLastChild = NULL; } if (ActiveItem) ActiveItem->Active(2); }
static String HHVM_FUNCTION(mysql_escape_string, const String& unescaped_string) { String new_str((size_t)unescaped_string.size() * 2 + 1, ReserveString); unsigned long new_len = mysql_escape_string(new_str.mutableData(), unescaped_string.data(), unescaped_string.size()); new_str.shrink(new_len); return new_str; }
MenuItem::MenuItem(const char* pszTitle) { memset(&next, 0, sizeof *this - sizeof(void*)); m_Justify = MENUITEM_STANDARD_JUSTIFY; //m_ItemID = MENUITEM_ID_NORMAL; //m_nSortPriority = M_SORT_NORMAL; m_pszTitle = new_str(pszTitle); ++g_menu_item_count; }
static void load_nls(void) { const char *lang_file = ReadString(extensionsrcPath(), "blackbox.options.language:", NULL); if (NULL == lang_file) return; char full_path[MAX_PATH]; FILE *fp = fopen (make_bb_path(full_path, lang_file), "rb"); if (NULL == fp) return; char line[4000], key[200], new_text[4000], *np; int nl; key[0] = 0; new_text[0] = 0; np = new_text; nl = 0; for (;;) { bool eof = false == read_next_line(fp, line, sizeof line); char *s = line, c = *s; if ('$' == c || eof) { if (key[0] && new_text[0]) { struct nls *t = (struct nls *)c_alloc(sizeof *t + strlen(key)); t->hash = calc_hash(t->key, key, &t->k); t->translation = new_str(new_text); cons_node(&pNLS, t); } if (eof) break; if (' ' == s[1]) s += 2; decode_escape(key, s); new_text[0] = 0; np = new_text; nl = 0; continue; } if ('#' == c || '!' == c) continue; if ('\0' != c) { while (nl--) *np++ = '\n'; np += decode_escape(np, s); nl = 0; } nl ++; } fclose(fp); reverse_list(&pNLS); }
/* * Private helper function to create a new block for a new file and initialize file params. * Parameters: * o const char* name - name of file. * Return : pointer to new block of file data */ static struct mfs_file* mfs_construct(const char* name) { void *fileHeaderMemory = myMalloc(sizeof(struct mfs_file)); setMemoryPid(fileHeaderMemory,SPECIAL_PID); struct mfs_file* newfile = (struct mfs_file*)fileHeaderMemory; void * blockMemory = myMalloc(BLOCK_SIZE); setMemoryPid(blockMemory,SPECIAL_PID); newfile->data = (unsigned char *)blockMemory; newfile->size = 0; newfile->fname = new_str(name); return newfile; }
void hd2prop_add_str(hal_prop_t **list, const char *key, const char *str) { hal_prop_t *prop; if(str) { prop = hal_get_new(list, key); prop->type = p_string; prop->val.str = new_str(str); } else { hal_invalidate_all(*list, key); } }
void Log::outDB(LogTypes type, const char * str) { if(!str || type >= MAX_LOG_TYPES) return; std::string new_str(str); if(new_str.empty()) return; LoginDatabase.EscapeString(new_str); LoginDatabase.PExecute("INSERT INTO logs (time, realm, type, string) " "VALUES (" UI64FMTD ", %u, %u, '%s');", uint64(time(0)), realm, type, new_str.c_str()); }
str make_str () { int n; str s; n = cur_length(); s = new_str(n); memcpy(s, cur_str, n); cur_str_ptr = cur_str; return s; }