static BOOLEAN LoadSisState (SIS_STATE *SSPtr, void *fp) { if ( read_32s (fp, &SSPtr->log_x) != 1 || read_32s (fp, &SSPtr->log_y) != 1 || read_32 (fp, &SSPtr->ResUnits) != 1 || read_32 (fp, &SSPtr->FuelOnBoard) != 1 || read_16 (fp, &SSPtr->CrewEnlisted) != 1 || read_16 (fp, &SSPtr->TotalElementMass) != 1 || read_16 (fp, &SSPtr->TotalBioMass) != 1 || read_a8 (fp, SSPtr->ModuleSlots, NUM_MODULE_SLOTS) != 1 || read_a8 (fp, SSPtr->DriveSlots, NUM_DRIVE_SLOTS) != 1 || read_a8 (fp, SSPtr->JetSlots, NUM_JET_SLOTS) != 1 || read_8 (fp, &SSPtr->NumLanders) != 1 || read_a16 (fp, SSPtr->ElementAmounts, NUM_ELEMENT_CATEGORIES) != 1 || read_str (fp, SSPtr->ShipName, SIS_NAME_SIZE) != 1 || read_str (fp, SSPtr->CommanderName, SIS_NAME_SIZE) != 1 || read_str (fp, SSPtr->PlanetName, SIS_NAME_SIZE) != 1 || read_16 (fp, NULL) != 1 /* padding */ ) return FALSE; else { // JMS: Let's make savegames work even between different resolution modes. SSPtr->log_x <<= RESOLUTION_FACTOR; SSPtr->log_y <<= RESOLUTION_FACTOR; return TRUE; } }
int main(void) { char usr_str[MAX_LEN], max_word[MAX_LEN], min_word[MAX_LEN]; int i; /* we must take the user's first word and arbitrarily appoint it both the * largest and smallest word - since we aren't making comparisons as with * folowing words, this portion must be outside the for loop */ printf("\nEnter word: "); /* read_str() returns -1 if the user's word was too long - since the while * loop calls read_str every time it evaluates its condition, and since * read_str() takes care of reading characters into usr_str, this loop * constitutes a complete error check for strings longer than 20 * characters */ while (read_str(usr_str, MAX_LEN) == -1) { printf("\nPlease try again: \n"); } /* arbitrarily put the user's first word into both max_word and min_word - * should this first word be four characters long, this will be both the * largest and the smallest string, and the program will print output and * terminate */ strcpy(max_word, usr_str); strcpy(min_word, usr_str); if (strlen(usr_str) == TERMINATE_LEN) { printf("\nSmallest word: %s\n", min_word); printf("\nLargest word: %s\n", max_word); return 0; } /* infinite for loop - breaks when the user enters a word of four characters, * but only after the word is compared to the current largest and smallest * words */ for (;;) { printf("Enter word: "); while (read_str(usr_str, MAX_LEN) == -1) { printf("\nPlease try again: "); } if (strcmp(usr_str, max_word) > 0) { strcpy(max_word, usr_str); } else if (strcmp(usr_str, min_word) < 0) { strcpy(min_word, usr_str); } if (strlen(usr_str) == TERMINATE_LEN) { break; } } /* output is printed here if the user's first word was not four characters * in length */ printf("\nSmallest word: %s\n", min_word); printf("\nLargest word: %s\n", max_word); return 0; }
button pcb_button(const JSON::node& root, const JSON::pointer& ptr) { auto pshadow = ptr.field("shadow"); auto pname = ptr.field("name"); auto psymbol = ptr.field("symbol"); auto pmacro = ptr.field("macro"); auto pmovie = ptr.field("movie"); struct button ret; ret.type = button::TYPE_BUTTON; ret.name = read_str(root, pname); std::u32string symbol = (root.type_of(psymbol) != JSON::none) ? read_str32(root, psymbol) : utf8::to32(ret.name); if(symbol.length() != 1) (stringfmt() << "Symbol at '" << ptr << "' must be 1 codepoint").throwex(); ret.symbol = symbol[0]; ret.rmin = 0; ret.rmax = 0; ret.centers = false; ret.macro = (root.type_of(pmacro) != JSON::none) ? read_str(root, pmacro) : utf8::to8(symbol); std::string movie = (root.type_of(pmovie) != JSON::none) ? read_str(root, pmovie) : utf8::to8(symbol); if(movie.length() != 1) (stringfmt() << "Movie at '" << ptr << "' must be 1 character").throwex(); ret.msymbol = movie[0]; ret.shadow = (root.type_of(pshadow) != JSON::none) ? read_bool(root, pshadow) : false; return ret; }
sys_shlfunc() #define sys_shl sys_shlfunc() {register int st,i,v ; st=cre(1); fprintf ( bstdout, "Shell (0 to quit): "); read_str(st); while( len_str(st)==0 ){ fprintf ( bstdout, "\n"); fprintf ( bstdout, "Shell (0 to quit): "); read_str(st); } while( fst_str(st)!=ord('0') ){ itr_str(st,i,v,cstr_shl[i-1]=chr(v)); cstr_shl[len_str(st)]='\0'; fprintf ( bstdout, "\n"); system(cstr_shl); fprintf ( bstdout, "\n"); fprintf ( bstdout, "Shell (0 to quit): "); read_str(st); while( len_str(st)==0 ){ fprintf ( bstdout, "\n"); fprintf ( bstdout, "Shell (0 to quit): "); read_str(st); } } }
struct controller_set* pcs_parse_set(const JSON::node& root, JSON::pointer ptr) { if(root.type_of_indirect(ptr) != JSON::object) (stringfmt() << "Expected (indirect) object for '" << ptr << "'").throwex(); ptr = root.resolve_indirect(ptr); controller_set* ret = NULL; auto pcontrollers = ptr.field("controllers"); auto plegal = ptr.field("legal"); auto phname = ptr.field("hname"); auto psymbol = ptr.field("symbol"); if(root.type_of_indirect(pcontrollers) != JSON::array) (stringfmt() << "Expected (indirect) array for '" << pcontrollers << "'").throwex(); JSON::pointer _controllers = root.resolve_indirect(pcontrollers); const JSON::node& n_controllers = root.follow(_controllers); std::vector<controller> controllers; for(auto i = n_controllers.begin(); i != n_controllers.end(); i++) controllers.push_back(pcs_parse_controller(root, _controllers.index(i.index()))); if(root.type_of_indirect(plegal) != JSON::array) (stringfmt() << "Expected (indirect) array for '" << plegal << "'").throwex(); JSON::pointer _legal = root.resolve_indirect(plegal); const JSON::node& n_legal = root.follow_indirect(_legal); std::set<unsigned> legal; for(auto i = n_legal.begin(); i != n_legal.end(); i++) legal.insert(read_int(root, _legal.index(i.index()))); std::string iname = read_str(root, ptr.field("name")); std::string hname = (root.type_of(phname) != JSON::none) ? read_str(root, phname) : iname; std::string symbol = (root.type_of(psymbol) != JSON::none) ? read_str(root, psymbol) : iname; ret = new controller_set; ret->iname = iname; ret->hname = hname; ret->symbol = symbol; ret->controllers = controllers; ret->legal_for = legal; return ret; }
void Server(semaphore sem,int fifo) { num_mem member; bool flag = true; lth = false; std::vector<pthread_t> threads; while (flag) { pthread_t temp; if(!lth && !isStr) { lth = true; std::string* ptr = &sent; pthread_create(&temp,NULL,getStr,NULL); threads.push_back(temp); } int val; if(!isStr) { sem_getvalue(sem.ws,&val); if(val == 0) { read_str(sem,fifo,&member); } } if(isStr) { sem_getvalue(sem.ws,&val); if(val == 0) { read_str(sem,fifo,&member); } else { if( sem_trywait(sem.ib) == 0) { sem_wait(sem.ws); int status = write_str(sem,fifo,sent,&member); isStr = false; } } } if(EF) { flag = false; end_seq(threads); return; } if(threads.size() > 100) { clear(threads); } } }
int init_settings_from_env() { if (read_str("TMC_SPYWARE_DATA_DIR", &settings.data_dir) <= 0) { return 0; } if (read_str("TMC_SPYWARE_AUTH_URL", &settings.auth_url) <= 0) { return 0; } return 1; }
static bool load_cached_font_list(struct serializer *s) { bool success = true; int count; success = read_var(s, count); if (!success) return false; da_init(font_list); da_resize(font_list, count); #define do_read(var) \ success = read_var(s, var); \ if (!success) break for (int i = 0; i < count; i++) { struct font_path_info *info = &font_list.array[i]; success = read_str(s, &info->face_and_style); if (!success) break; do_read(info->full_len); do_read(info->face_len); do_read(info->is_bitmap); do_read(info->num_sizes); info->sizes = bmalloc(sizeof(int) * info->num_sizes); success = read_data(s, info->sizes, sizeof(int) * info->num_sizes); if (!success) break; do_read(info->bold); success = read_str(s, &info->path); if (!success) break; do_read(info->italic); do_read(info->index); } #undef do_read if (!success) { free_os_font_list(); return false; } return true; }
int main (int argc, char * argv[]) { trv_struc base; char * fname1, *fname2; int lado; mat_str str, str_rot; win_struc win_ero; trv_struc_list * lower, * apt_list; fname1 = argv[1]; fname2 = argv[2]; zera_basis_by_ron (&base); read_itrv (fname1, &base); read_str (fname2, &str); beatriz = 1; gera_lower_bounds_crescente (&lower, &base, &str); lado = 0; while (lower) { apt_list = lower; lower = lower->prox; printf ("Lower Basis %03d:\n", ++lado); disp_basis_by_ron (&apt_list->base); free_basis_by_ron (&apt_list->base); free (apt_list); } free_basis_by_ron (&base); if (str.tag == MM_IMG && str.dat) free (str.dat); }
int Scanner::GetToken(int *sub) { *sub = 0; skip_non_token(); // char c = cur_char(); if (is_dec(c)) { return read_num(); } // struct OperatorTableEntry *op = lookup_op(); if (op) { int r; r = read_op(op); *sub = op->sub_op; return r; } // if (c == '\"') { return read_str(); } if (is_symhead(c)) { return read_sym(); } return -1; }
/* * Read some house info */ static void rd_house(int n) { house_type *house_ptr = &houses[n]; start_section_read("house"); /* coordinates of corners of house */ house_ptr->x_1 = read_int("x1"); house_ptr->y_1 = read_int("y1"); house_ptr->x_2 = read_int("x2"); house_ptr->y_2 = read_int("y2"); /* coordinates of the house door */ house_ptr->door_y = read_int("door_y"); house_ptr->door_x = read_int("door_x"); /* Door Strength */ house_ptr->strength = read_int("strength"); /* Owned or not */ read_str("owned",house_ptr->owned); house_ptr->depth = read_int("depth"); house_ptr->price = read_int("price"); end_section_read("house"); }
std::unique_ptr<tag> io::read(std::istream& is, std::string& key) { tag::tag_type tt = read_type(is); key = read_str(is); if(!is) throw tag::input_error((boost::format("Error reading name of tag_%1%") % tt).str()); return read_payload(tt, is); }
/* * Read some party info FOUND THE BUIG!!!!!! the disapearing party bug. no more. I hope...... -APD- */ static void rd_party(int n) { party_type *party_ptr = &parties[n]; start_section_read("party"); /* Party name */ read_str("name",party_ptr->name); /* Party owner's name */ read_str("owner",party_ptr->owner); /* Number of people and creation time */ party_ptr->num = read_int("num"); read_hturn("created", &party_ptr->created); end_section_read("party"); }
/* Parse the string in *src as JSON, and write the result into *dst. * max_depth limits the recursion and JSON tree depth. * Warning: this overwrites the input string (what *src points to)! * Returns: * 0: success, *dst is valid, *src points to the end (the caller must check * whether *src really terminates) * -1: failure, *dst is invalid, there may be dead allocs under ta_parent * (ta_free_children(ta_parent) is the only way to free them) * The input string can be mutated in both cases. *dst might contain string * elements, which point into the (mutated) input string. */ int json_parse(void *ta_parent, struct mpv_node *dst, char **src, int max_depth) { max_depth -= 1; if (max_depth < 0) return -1; eat_ws(src); char c = **src; if (!c) return -1; // early EOF if (c == 'n' && strncmp(*src, "null", 4) == 0) { *src += 4; dst->format = MPV_FORMAT_NONE; return 0; } else if (c == 't' && strncmp(*src, "true", 4) == 0) { *src += 4; dst->format = MPV_FORMAT_FLAG; dst->u.flag = 1; return 0; } else if (c == 'f' && strncmp(*src, "false", 5) == 0) { *src += 5; dst->format = MPV_FORMAT_FLAG; dst->u.flag = 0; return 0; } else if (c == '"') { return read_str(ta_parent, dst, src); } else if (c == '[' || c == '{') { return read_sub(ta_parent, dst, src, max_depth); } else if (c == '-' || (c >= '0' && c <= '9')) { // The number could be either a float or an int. JSON doesn't make a // difference, but the client API does. char *nsrci = *src, *nsrcf = *src; errno = 0; long long int numi = strtoll(*src, &nsrci, 0); if (errno) nsrci = *src; errno = 0; double numf = strtod(*src, &nsrcf); if (errno) nsrcf = *src; if (nsrci >= nsrcf) { *src = nsrci; dst->format = MPV_FORMAT_INT64; // long long is usually 64 bits dst->u.int64 = numi; return 0; } if (nsrcf > *src && isfinite(numf)) { *src = nsrcf; dst->format = MPV_FORMAT_DOUBLE; dst->u.double_ = numf; return 0; } return -1; } return -1; // character doesn't start a valid token }
AST_expr* readASTExpr(BufferedReader* reader) { uint8_t type = reader->readByte(); if (VERBOSITY("parsing") >= 2) printf("type = %d\n", type); if (type == 0) return NULL; uint8_t checkbyte = reader->readByte(); assert(checkbyte == 0xae); switch (type) { case AST_TYPE::Attribute: return read_attribute(reader); case AST_TYPE::BinOp: return read_binop(reader); case AST_TYPE::BoolOp: return read_boolop(reader); case AST_TYPE::Call: return read_call(reader); case AST_TYPE::Compare: return read_compare(reader); case AST_TYPE::Dict: return read_dict(reader); case AST_TYPE::DictComp: return read_dictcomp(reader); case AST_TYPE::IfExp: return read_ifexp(reader); case AST_TYPE::Index: return read_index(reader); case AST_TYPE::Lambda: return read_lambda(reader); case AST_TYPE::List: return read_list(reader); case AST_TYPE::ListComp: return read_listcomp(reader); case AST_TYPE::Name: return read_name(reader); case AST_TYPE::Num: return read_num(reader); case AST_TYPE::Repr: return read_repr(reader); case AST_TYPE::Slice: return read_slice(reader); case AST_TYPE::Str: return read_str(reader); case AST_TYPE::Subscript: return read_subscript(reader); case AST_TYPE::Tuple: return read_tuple(reader); case AST_TYPE::UnaryOp: return read_unaryop(reader); default: fprintf(stderr, "Unknown expr node type (parser.cpp:" STRINGIFY(__LINE__) "): %d\n", type); abort(); break; } }
void pkcs11_generate(FILE * outfile, const char *url, gnutls_pk_algorithm_t pk, unsigned int bits, const char *label, const char *id, int detailed, unsigned int flags, common_info_st * info) { int ret; gnutls_datum_t pubkey; gnutls_datum_t cid = {NULL, 0}; unsigned char raw_id[128]; size_t raw_id_size; pkcs11_common(info); FIX(url, outfile, detailed, info); CHECK_LOGIN_FLAG(flags); if (id != NULL) { raw_id_size = sizeof(raw_id); ret = gnutls_hex2bin(id, strlen(id), raw_id, &raw_id_size); if (ret < 0) { fprintf(stderr, "Error converting hex: %s\n", gnutls_strerror(ret)); exit(1); } cid.data = raw_id; cid.size = raw_id_size; } if (outfile == stderr || outfile == stdout) { fprintf(stderr, "warning: no --outfile was specified and the generated public key will be printed on screen.\n"); } if (label == NULL && info->batch == 0) { label = read_str("warning: Label was not specified.\nLabel: "); } ret = gnutls_pkcs11_privkey_generate3(url, pk, bits, label, &cid, GNUTLS_X509_FMT_PEM, &pubkey, info->key_usage, flags); if (ret < 0) { fprintf(stderr, "Error in %s:%d: %s\n", __func__, __LINE__, gnutls_strerror(ret)); if (bits != 1024 && pk == GNUTLS_PK_RSA) fprintf(stderr, "note: several smart cards do not support arbitrary size keys; try --bits 1024 or 2048.\n"); exit(1); } fwrite(pubkey.data, 1, pubkey.size, outfile); gnutls_free(pubkey.data); UNFIX; return; }
static int read_int(char *line, char *param) { char *tmp; int value; tmp = read_str(line, param); sscanf(tmp, "%i", &value); return value; }
static float read_float(char *line, char *param) { char *tmp; float value; tmp = read_str(line, param); sscanf(tmp, "%f", &value); return value; }
static double read_double(char *line, char *param) { char *tmp; double value; tmp = read_str(line, param); sscanf(tmp, "%lf", &value); return value; }
int read_data(const char *file) { size_t i; FILE *fin = fopen(file, "r"); if (fin == NULL) goto exit_no_file; fscanf(fin, "%zu", &idata_count); if (feof(fin) || ferror(fin)) goto exit_bad_file; idata = malloc(idata_count * sizeof *idata); if (idata == NULL) goto exit_no_mem; for (i = 0; i < idata_count; ++i) fscanf(fin, "%d", &idata[i]); if (feof(fin) || ferror(fin)) goto exit_bad_file; fscanf(fin, "%zu", &sdata_count); if (feof(fin) || ferror(fin)) goto exit_bad_file; sdata = malloc(sdata_count * sizeof *sdata); if (sdata == NULL) goto exit_no_mem; for (i = 0; i < sdata_count; ++i) { sdata[i] = read_str(fin); /* could also be no memory, but chances of this is higher */ if (sdata[i] == NULL) goto exit_bad_file; } fclose(fin); return 0; exit_no_file: printf("no such file: \"%s\"\n", file); goto exit_fail; exit_bad_file: printf("bad file format\n"); goto exit_yes_file; exit_no_mem: printf("out of memory\n"); exit_yes_file: fclose(fin); exit_fail: cleanup_data(); return -1; }
void command_pwd(t_env *env, char **splitted) { char *path; write_long(env, COMMAND_PWD); path = read_str(env); ft_putendl(path); ft_putendl("SUCCESS"); free(path); (void)splitted; }
static void print_kdump(void) { struct stat sb; char tmp[1024]; if (stat("/sys/kernel/kexec_crash_loaded", &sb) != 0) return; read_str(tmp, "/sys/kernel/kexec_crash_loaded", sizeof(tmp)); if (strncmp(tmp, "1", 1) == 0) printf("kdump,"); }
int read_int(char *b, char *f, int *n) { char buff[256]; if(read_str(b, f, buff, sizeof(buff)) < 0) return -1; /* read value */ sscanf(buff, "%d", n); return 0; }
/* This is wrapper around read_str() (which see for details); it simply asks svn_path_is_canonical() of the string it reads, returning an error if the test fails. ### It seems this is only called for entrynames now */ static svn_error_t * read_path(const char **result, char **buf, const char *end, apr_pool_t *pool) { SVN_ERR(read_str(result, buf, end, pool)); if (*result && **result && !svn_relpath_is_canonical(*result)) return svn_error_createf(SVN_ERR_WC_CORRUPT, NULL, _("Entry contains non-canonical path '%s'"), *result); return SVN_NO_ERROR; }
struct controller pcs_parse_controller(const JSON::node& root, JSON::pointer ptr) { if(root.type_of_indirect(ptr) != JSON::object) (stringfmt() << "Expected (indirect) object for '" << ptr << "'").throwex(); ptr = root.resolve_indirect(ptr); controller ret; auto pbuttons = ptr.field("buttons"); std::string cclass = read_str(root, ptr.field("class")); std::string type = read_str(root, ptr.field("type")); if(root.type_of_indirect(pbuttons) != JSON::array) (stringfmt() << "Expected (indirect) array for '" << pbuttons << "'").throwex(); JSON::pointer _buttons = root.resolve_indirect(pbuttons); const JSON::node& n_buttons = root.follow(_buttons); std::vector<button> buttons; for(auto i = n_buttons.begin(); i != n_buttons.end(); i++) buttons.push_back(pcs_parse_button(root, _buttons.index(i.index()))); ret.cclass = cclass; ret.type = type; ret.buttons = buttons; return ret; }
int RDFParser::read_main(stringstream & stream) { int ret; ret=read_str(stream, "main"); if (ret < 0) return ret; ret=read_conditions(stream); if (ret < 0) return ret; return 0; }
static int recv_bsd_auth (int s, u_char *buf, struct sockaddr_in *thisaddr, struct sockaddr_in *thataddr, char **client_username, char **server_username, char **cmd) { struct passwd *pwd; *client_username = read_str (s, USERNAME_SZ, "local username"); *server_username = read_str (s, USERNAME_SZ, "remote username"); *cmd = read_str (s, ARG_MAX + 1, "command"); pwd = getpwnam(*server_username); if (pwd == NULL) fatal(s, NULL, "Login incorrect."); if (iruserok(thataddr->sin_addr.s_addr, pwd->pw_uid == 0, *client_username, *server_username)) fatal(s, NULL, "Login incorrect."); return 0; }
static void read_next(ParseInfo pi, const char *key) { VALUE obj; if ((void*)&obj < pi->stack_min) { rb_raise(rb_eSysStackError, "JSON is too deeply nested"); } next_non_white(pi); /* skip white space */ switch (*pi->s) { case '{': read_hash(pi, key); break; case '[': read_array(pi, key); break; case '"': read_str(pi, key); break; case '+': case '-': case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': read_num(pi, key); break; case 'I': read_num(pi, key); break; case 't': read_true(pi, key); break; case 'f': read_false(pi, key); break; case 'n': read_nil(pi, key); break; case '\0': return; default: return; } }
/* returns false if a option was missing */ bool Profile::load_profile(const char *section) { int ires, *tvar; float fres, *fvar; bool tres, res = true; struct stat st; if(!cfg) return(false); /* no setup() called */ if(stat(profile_path, &st) == -1) return(false); /* file not there */ for(int i=0;cfg[i].name;i++) { switch(cfg[i].type) { case cfgINT: tvar = (int*)cfg[i].var; ires = read_int(section,cfg[i].name); *tvar = (ires<0) ? atoi(cfg[i].defval) : ires; func("load_profile(%s) parsed %s value %i", section, cfg[i].name, *(int*)cfg[i].var); res &= (ires>=0); break; case cfgSTR: tres = read_str(section,cfg[i].name,(char*)cfg[i].var); if(!tres) { snprintf((char*)cfg[i].var,MAX_VALUE_SIZE,"%s",cfg[i].defval); res = false; } func("load_profile(%s) parsed %s value %s", section, cfg[i].name,(char*)cfg[i].var); break; case cfgFLOAT: fvar = (float*)cfg[i].var; fres = read_float(section,cfg[i].name); if(fres==-1.0f) { sscanf(cfg[i].defval,"%f",fvar); res = false; } else *fvar = fres; func("load_profile(%s) parsed %s value %.4f", section, cfg[i].name, *(float*)cfg[i].var); break; case cfgNULL: break; } } return(res); }
int RDFParser::read_rules(stringstream & stream) { int ret=0; string rulename; string rulestr; Rule * rule; rdfg->graph->resolve(); while (ret >= 0) { ret = check_str(stream, "rule"); if (ret<0) break; stream >> rulename; rule = new Rule(rulename); ret = read_str(stream, "{"); if (ret < 0) return ret; ret = read_str(stream, "left"); if (ret < 0) return ret; ret = read_graph(stream, rule->left()); if (ret < 0) return ret; ret = read_str(stream, "right"); if (ret < 0) return ret; ret = read_graph(stream, rule->right()); if (ret < 0) return ret; ret = read_str(stream, "}"); if (ret < 0) return ret; rule->preprocess(); rdfg->add_rule(rule); } return 0; }