/*----------------------------------------------------------------------------*/ void music_info_init(void) { #ifdef USB_SD_DECODE_DEFAULT_REP_OFF play_mode=REPEAT_OFF; #else play_mode = read_info(MEM_PLAY_MODE); if (play_mode > REPEAT_RANDOM) { play_mode = REPEAT_ALL; } #endif if (given_device == 0) //设备启动时,given_device为0; { given_device = read_info(MEM_ACTIVE_DEV); if ((given_device != 0x01) && (given_device != 0x02)) { given_device = 0x01; given_file_number = 1; } } eq_mode = read_info(MEM_EQ_MODE); if (eq_mode > CLASSIC) { eq_mode = NORMAL; } }
int request_usr(simple_person ** arr, int * size, int id,char * conect, tOPC opc) { char opOK=0,qty_people=0; int full_size; clsvbuff buff; initConnection(TYPE_MSG_Q); buff.opc=opc; buff.id_client=id; write_info(&buff); read_info(&opOK,sizeof(char),buff.id_client); if(opOK==NOTOK) { return NOTOK; } read_info((char*)&qty_people,sizeof(char),buff.id_client); *size=qty_people; full_size=sizeof(simple_person) * (*size); if(full_size>0) { *arr=malloc(full_size); if(*arr==NULL) return NOTOK; read_info((char*) (*arr),full_size,buff.id_client); } return OK; }
u16 read_radio_freq(u8 ch) { xd_u16 freq_reg=0; freq_reg = read_info(ch+1); freq_reg=freq_reg<<8; freq_reg |= read_info(ch); return freq_reg; }
u16 read_radio_freq(u8 ch) { xd_u16 freq_reg=0; ch=ch<<1; freq_reg = read_info(MEM_FM_CHANNL +ch+1); freq_reg=freq_reg<<8; freq_reg |= read_info(MEM_FM_CHANNL +ch); return freq_reg; }
/*----------------------------------------------------------------------------*/ void restore_music_point(void) { u8 i; for (i = 0;i<10;i++) { ((u8 *)(&(disk_mus_point[0].id0)))[i] = read_info(MEM_SD_PLAYPOINT_ID0+i); } for (i = 0;i<10;i++) { ((u8 *)(&(disk_mus_point[1].id0)))[i] = read_info(MEM_USB_PLAYPOINT_ID0+i); } }
void print_list_rest (FILE * in) { char stringBuf[1024]; GList *ac = NULL; GList *list = read_info (in); list = g_list_sort (list, CompareAccountByUsername); printf (" USER REASON PERIOD LEVEL TIME LEFT(s)\n"); for (ac = g_list_first (list); ac != NULL; ac = g_list_next (ac)) { Account *_ac = (Account *) ac->data; if (_ac->info.field_restrict != NO_PERIOD) { //printf( " %-16s %-6s %-6s %c %-4d\n", printf (" %-16s %-6s %-6s %c %d\n", _ac->id, //name read_restrict_reason (_ac), //reason read_restrict_reriod (_ac), //period get_restrict_level (_ac->restricted), //level get_time_to_end (_ac) //time left ); } free (_ac->id); free (_ac); } g_list_free (list); }
int main() { char service_name[256]; printf("Input service name you want to connect:\n"); fgets(service_name, sizeof(service_name), stdin); if (service_name[strlen(service_name) - 1] == '\n') service_name[strlen(service_name) - 1] = '\0'; if (!connect_to_service(service_name)) { fprintf(stderr, "connect_to_service failed\n"); exit(EXIT_FAILURE); } if (!read_info()) { fprintf(stderr, "read_info failed\n"); exit(EXIT_FAILURE); } if (socketfd != -1) { close(socketfd); } exit(EXIT_SUCCESS); }
int main(int argc, char *argv[]) { char *p; size_t len; Subrange *r; int (*fn)(Rune **r0, Rune **r1, Rune **r2, Rune **r3); p = strrchr(argv[0], '/'); p = p? p+1 : argv[0]; switch (*p) { case 'c' : fn = fn_c; break; case 'i' : fn = fn_i; break; case 'd' : fn = fn_d; break; case 'a' : fn = fn_a; break; default: fprintf(stderr,"Uknown program name!\n"); exit(1); } if (*p != 'd') { if (argc < 2) { fprintf(stderr,"%c: need text argument\n", *p); exit(1); } argtorune(argv[1]); } read_info(0); /* don't reverse ranges */ do_changes(fn); list_changes(); exit(0); }
static void get_connections_complete(int sk, void *buf, size_t len) { struct mgmt_rp_get_connections *rp = buf; struct controller_info *info; uint16_t index; int i; if (len < sizeof(*rp)) { error("Too small get_connections complete event"); return; } if (len < (sizeof(*rp) + (rp->conn_count * sizeof(bdaddr_t)))) { error("Too small get_connections complete event"); return; } index = btohs(bt_get_unaligned(&rp->index)); if (index > max_index) { error("Unexpected index %u in get_connections complete", index); return; } info = &controllers[index]; for (i = 0; i < rp->conn_count; i++) { bdaddr_t *bdaddr = g_memdup(&rp->conn[i], sizeof(bdaddr_t)); info->connections = g_slist_append(info->connections, bdaddr); } read_info(sk, index); }
/*----------------------------------------------------------------------------*/ void music_info_init(void) { #ifdef NO_REM_LAST_DEV given_device = NO_DEVICE; #else given_device = read_info(MEM_ACTIVE_DEV); #endif if (given_device == DEVICE_SDMMC0) { Set_Curr_Func(SYS_MP3DECODE_SD); given_file_method = PLAY_FIRST_FILE; given_device = DEVICE_SDMMC0; put_msg_lifo(MSG_MUSIC_SELECT_NEW_DEVICE); } else if (given_device == DEVICE_UDISK) { Set_Curr_Func(SYS_MP3DECODE_USB); given_file_method = PLAY_FIRST_FILE; given_device = DEVICE_UDISK; put_msg_lifo(MSG_MUSIC_SELECT_NEW_DEVICE); } else { Set_Curr_Func(SYS_MP3DECODE_USB); given_file_method = PLAY_FIRST_FILE; given_device = DEVICE_UDISK; put_msg_lifo(MSG_MUSIC_SELECT_NEW_DEVICE); } }
int IndexFile::open_index(Asset *asset) { // use buffer if being built this->asset = asset; int result = 0; if(asset->index_status == INDEX_BUILDING) { // use buffer result = 0; } else if(!(result = open_file())) { // opened existing file if(read_info()) { result = 1; close_index(); } else { asset->index_status = INDEX_READY; } } else { result = 1; } return result; }
/** * Add a pseudonym to the set of known pseudonyms. * For all pseudonym advertisements that we discover * FS should automatically call this function. * * @param cfg overall configuration * @param id the pseudonym identifier * @param meta metadata for the pseudonym */ void GNUNET_PSEUDONYM_add (const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_HashCode * id, const struct GNUNET_CONTAINER_MetaData *meta) { char *name; int32_t ranking; struct GNUNET_CONTAINER_MetaData *old; char *fn; struct stat sbuf; ranking = 0; fn = get_data_filename (cfg, PS_METADATA_DIR, id); GNUNET_assert (fn != NULL); if ((0 == STAT (fn, &sbuf)) && (GNUNET_OK == read_info (cfg, id, &old, &ranking, &name))) { GNUNET_CONTAINER_meta_data_merge (old, meta); write_pseudonym_info (cfg, id, old, ranking, name); GNUNET_CONTAINER_meta_data_destroy (old); GNUNET_free_non_null (name); } else { write_pseudonym_info (cfg, id, meta, ranking, NULL); } GNUNET_free (fn); internal_notify (id, meta, ranking); }
int do_info(const char *const *argv) { const char *thisarg; struct partinfo *pi, ps; struct dpkg_ar *part; if (!*argv) badusage(_("--%s requires one or more part file arguments"), cipaction->olong); while ((thisarg= *argv++)) { part = dpkg_ar_open(thisarg); if (!part) ohshite(_("cannot open archive part file '%.250s'"), thisarg); pi = read_info(part, &ps); dpkg_ar_close(part); if (pi) { print_info(pi); } else { printf(_("file '%s' is not an archive part\n"), thisarg); } m_output(stdout, _("<standard output>")); } return 0; }
bool Channel::read_tile_or_closest_ancestor(TileIndex ti, TileIndex &ret_index, Tile &ret) const { Locker lock(*this); // Lock self and hold lock until exiting this method ChannelInfo info; bool success = read_info(info); if (!success) { if (verbosity) log_f("read_tile_or_closest_ancestor: can't read info"); return false; } TileIndex root = info.nonnegative_root_tile_index; if (ti.is_ancestor_of(root)) { ret_index = root; } else { if (ti != root && !root.is_ancestor_of(ti)) { // Tile isn't under root return false; } assert(tile_exists(root)); ret_index = root; while (ret_index != ti) { TileIndex child = ti.start_time() < ret_index.left_child().end_time() ? ret_index.left_child() : ret_index.right_child(); if (!tile_exists(child)) break; ret_index = child; } } // ret_index now holds closest ancestor to ti (or ti itself if it exists) assert(read_tile(ret_index, ret)); return true; }
/*----------------------------------------------------------------------------*/ static void sys_info_init(void) { //u8 vol_tmp; #if 1 sys_main_vol = read_info(MEM_SYS_VOL); if ((sys_main_vol > MAX_MAIN_VOL) || (sys_main_vol == 0)) //每次开机时,不要超过最大音量的一半,以免开机音量过大 { sys_main_vol = 20; } #endif dac_init(sys_main_vol); delay_10ms(50); //等待,检测USB,SD在线状态 //init_rec_name(); //restore_music_point(); #if 0 #if RTC_ENABLE if (work_mode != RTC_MODE) #endif { device_check(); #if USB_DEVICE_ENABLE if (pc_connect) work_mode = USB_DEVICE_MODE; else if (udisk_connect || sdmmc_connect) work_mode = MUSIC_MODE; #else // if (udisk_connect || sdmmc_connect) // work_mode = MUSIC_MODE; #endif } #endif }
/*----------------------------------------------------------------------------*/ void enter_fm_rev(void) { u8 i; all_channl = read_info(MEM_ALL_CHANNL); if (all_channl > MAX_CHANNL) { all_channl = MAX_CHANNL; } for (i = 0;i<all_channl;i++) { fre_point[i] = read_info(MEM_CHANNL+i); #ifdef UART_ENABLE_FM printf(" ----FM read station from ROM %4u \r\n",(u16)(fre_point[i]+MIN_FRE)); #endif } fre_channl = read_info(MEM_FRE_CHANNL);//MEM_FRE if (fre_channl > all_channl) { fre_channl = 1; } else if (!fre_channl) { fre_channl = 1; } frequency = read_info(MEM_FRE)+MIN_FRE; if ( frequency > MAX_FRE) { frequency = MIN_FRE; } else if (frequency < MIN_FRE) { frequency = MIN_FRE; } #if defined(K738_LHD_LTB1_V001)||defined(K740_LHD_916_V001) frequency = 880; #endif #if defined(CUSTOM_RADIO_FREQ_875) frequency = 875; #endif }
void mustgetpartinfo(const char *filename, struct partinfo *ri) { FILE *part; part= fopen(filename,"r"); if (!part) ohshite(_("cannot open archive part file `%.250s'"),filename); if (!read_info(part,filename,ri)) ohshite(_("file `%.250s' is not an archive part"),filename); fclose(part); }
/** Try to open project /name/. Returns 0 if sucsessful, an error code * otherwise */ int Project::open ( const char *name ) { if ( ! validate( name ) ) return E_INVALID; close(); chdir( name ); if ( ! acquire_lock( &_lockfd, ".lock" ) ) return E_LOCKED; int version; char *creation_date; char *created_by; if ( ! read_info( &version, &creation_date, &created_by ) ) return E_INVALID; if ( strncmp( created_by, APP_TITLE, strlen( APP_TITLE ) ) ) return E_INVALID; if ( version != PROJECT_VERSION ) return E_VERSION; _is_opening = true; if ( ! Loggable::replay( "snapshot" ) ) return E_INVALID; if ( creation_date ) { strcpy( _created_on, creation_date ); free( creation_date ); } else *_created_on = 0; getcwd( _path, sizeof( _path ) ); set_name( _path ); _is_open = true; _is_opening = false; // tle->load_timeline_settings(); // timeline->zoom_fit(); // Loggable::clear_dirty(); MESSAGE( "Loaded project \"%s\"", name ); return 0; }
void read_info(typename Ptree::BOOST_NESTED_TEMPLATE for_char<Ch>::basic_istream &stream, Ptree &pt, const Ptree &default_ptree) { try { read_info(stream, pt); } catch(file_parser_error &) { pt = default_ptree; } }
void read_info(std::basic_istream<Ch> &stream, Ptree &pt, const Ptree &default_ptree) { try { read_info(stream, pt); } catch(file_parser_error &) { pt = default_ptree; } }
int get_person(person *p,int person_id,int src_id,char * conect) { char opOK=0; clsvbuff buff; initConnection(TYPE_MSG_Q); buff.opc=GET_INFO; buff.id_client=src_id; buff.data.clsv_get_info.id=person_id; write_info(&buff); read_info(&opOK, sizeof(char), buff.id_client); read_info((char *)p, sizeof(person), buff.id_client); return opOK; }
/*----------------------------------------------------------------------------*/ static void sys_info_init(void) { sys_main_vol = read_info(MEM_VOL); if ((sys_main_vol > MAX_MAIN_VOL) || (sys_main_vol == 0)) //每次开机时,不要超过最大音量的一半,以免开机音量过大 { sys_main_vol = MAX_MAIN_VOL / 2; } sys_main_vol = MAX_MAIN_VOL / 2; dac_init(MAX_MAIN_VOL); dsp_set_adc_con((0x0070)); delay_10ms(200); //等待,检测USB,SD在线状态 init_rec_name(); restore_music_point(); #if 0 #if RTC_ENABLE if (work_mode != RTC_MODE) #endif { device_check(); #if USB_DEVICE_ENABLE if (pc_connect) work_mode = USB_DEVICE_MODE; else if (udisk_connect || sdmmc_connect) work_mode = MUSIC_MODE; #else if (udisk_connect || sdmmc_connect) work_mode = MUSIC_MODE; #endif else { work_mode = read_info(MEM_SYSMODE); if (work_mode > MAX_WORK_MODE) { work_mode = MUSIC_MODE; } } } #endif }
GPtrArray * addMemoryUser (FILE * in, GPtrArray * tags) { DbCtlFoundTag *found_tag_list = NULL; GList *ac = NULL; GList *list = read_info (in); GPtrArray *Tags = tags; for (ac = g_list_first (list); ac != NULL; ac = g_list_next (ac)) { found_tag_list = (DbCtlFoundTag *) malloc (sizeof (DbCtlFoundTag)); strcpy (found_tag_list->tag, "user"); found_tag_list->attr = g_hash_table_new_full (g_str_hash, g_str_equal, (GDestroyNotify) found_tag_key_destroyed, (GDestroyNotify) found_tag_data_destroyed); found_tag_list->limit_attr = g_ptr_array_new (); Account *_ac = (Account *) ac->data; int found_user = 0, i = 0; for (; i < Tags->len; i++) { DbCtlFoundTag *found_tag_ = g_ptr_array_index (Tags, i); char *name_list = GetUserName (found_tag_->attr); if (name_list) if (strcmp (name_list, _ac->id) == 0) found_user++; } if (!found_user) { char *key_ = g_strdup ("name"); char *val_ = g_strdup (_ac->id); g_hash_table_insert (found_tag_list->attr, key_, val_); key_ = g_strdup ("mode"); val_ = g_strdup ("restrict"); g_hash_table_insert (found_tag_list->attr, key_, val_); g_ptr_array_add (Tags, found_tag_list); } else { if (found_tag_list->attr) g_hash_table_destroy (found_tag_list->attr); if (found_tag_list->limit_attr) g_ptr_array_free (found_tag_list->limit_attr, TRUE); free (found_tag_list); } free (_ac->id); free (_ac); } g_list_free (list); return Tags; }
/*----------------------------------------------------------------------------*/ void save_fm_point(u8 fre) { u8 i,j, k; i = fre / 8; k = fre % 8; j = read_info(MEM_CHANNL + i) | BIT(k); write_info(MEM_CHANNL + i, j); }
InfoEditor& InfoEditor::insert(const std::string& section, std::istream& stream) { boost::property_tree::ptree pt; read_info(stream, pt); m_info.add_child(section.c_str(), pt); return *this; }
std::string Channel::dump_tile_summaries() const { Locker lock(*this); // Lock self and hold lock until exiting this method ChannelInfo info; bool success = read_info(info); if (success) { return dump_tile_summaries_internal(info.nonnegative_root_tile_index, 0); } else { return ""; } }
void mustgetpartinfo(const char *filename, struct partinfo *ri) { struct dpkg_ar *part; part = dpkg_ar_open(filename); if (!part) ohshite(_("cannot open archive part file '%.250s'"), filename); if (!read_info(part, ri)) ohshite(_("file '%.250s' is not an archive part"), filename); dpkg_ar_close(part); }
void read_info(const std::string &filename, Ptree &pt, const Ptree &default_ptree, const std::locale &loc = std::locale()) { try { read_info(filename, pt, loc); } catch(file_parser_error &) { pt = default_ptree; } }
int evaluate(boolean * match,boolean opinion,int person_id, int src_id,char * conect) { char opOK=0; clsvbuff buff; initConnection(TYPE_MSG_Q); buff.id_client=src_id; buff.opc=EVALUATION; buff.data.clsv_evaluation.id=person_id; buff.data.clsv_evaluation.like=opinion; write_info(&buff); read_info(&opOK, sizeof(char), buff.id_client); read_info((char *)match, sizeof(boolean), buff.id_client); if(opOK==NOTOK) return NOTOK; return OK; }
void Config::load() { try { read_info(path, props); } catch (pt::info_parser_error &) { // It's OK if specific configuration doesn't exist yet. if (fs::exists(path)) { throw; } } }