void load_acorn(int rnum, int how_many) { int r, obj_num, znum, n, DROP = 0; struct obj_data *acorn; znum = world[real_room(rnum)].zone; for (n = 0; n <= how_many; n++) { r = number(rnum, (rnum + 99)); if (real_room(r)) { obj_num = real_object(200); acorn = read_object(obj_num, REAL); obj_to_room(acorn, real_room(r)); DROP = 1; } } if (DROP) { send_to_zone_outdoor(znum, "In the distance, you hear an acorn fall to the ground with a rustle of leaves.\r\n"); } obj_num = real_object(599); acorn = read_object(obj_num, REAL); obj_to_room(acorn, real_room(220)); }
static bool read_objectList(SerdReader* reader, ReadContext ctx, bool* ate_dot) { TRY_RET(read_object(reader, ctx, ate_dot)); while (!*ate_dot && eat_delim(reader, ',')) { TRY_RET(read_object(reader, ctx, ate_dot)); } return true; }
struct obj_data *Obj_from_store(struct obj_file_elem object, int *location) { struct obj_data *obj; int j; *location = 0; if (real_object(object.item_number) != NOTHING) { obj = read_object(object.item_number, VIRTUAL); #if USE_AUTOEQ *location = object.location; #endif GET_OBJ_VAL(obj, 0) = object.value[0]; GET_OBJ_VAL(obj, 1) = object.value[1]; GET_OBJ_VAL(obj, 2) = object.value[2]; GET_OBJ_VAL(obj, 3) = object.value[3]; GET_OBJ_EXTRA(obj) = object.extra_flags; GET_OBJ_WEIGHT(obj) = object.weight; GET_OBJ_TIMER(obj) = object.timer; obj->obj_flags.bitvector = object.bitvector; for (j = 0; j < MAX_OBJ_AFFECT; j++) obj->affected[j] = object.affected[j]; return (obj); } else return (NULL); }
void mag_creations(int level, struct char_data *ch, int spellnum) { struct obj_data *tobj; obj_vnum z; if (ch == NULL) return; /* level = MAX(MIN(level, LVL_IMPL), 1); - Hm, not used. */ switch (spellnum) { case SPELL_CREATE_FOOD: z = 10; break; default: send_to_char(ch, "Spell unimplemented, it would seem.\r\n"); return; } if (!(tobj = read_object(z, VIRTUAL))) { send_to_char(ch, "I seem to have goofed.\r\n"); log("SYSERR: spell_creations, spell %d, obj %d: obj not found", spellnum, z); return; } obj_to_char(tobj, ch); act("$n creates $p.", FALSE, ch, tobj, 0, TO_ROOM); act("You create $p.", FALSE, ch, tobj, 0, TO_CHAR); }
void perform_defile(struct room_data *room, int *state, char **olddesc, char **oldtitle) { struct obj_data *fount = NULL; if (*state != STATE_HOLY) { errlog("invalid state in perform_defile from unholy_square."); return; } *state = STATE_UNHOLY; for (fount = room->contents; fount; fount = fount->next_content) if (GET_OBJ_VNUM(fount) == FOUNT_HOLY) { extract_obj(fount); break; } if (!(fount = read_object(FOUNT_UNHOLY))) errlog("unable to load unholy fount in unholy_square."); else obj_to_room(fount, room); *olddesc = room->description; *oldtitle = room->name; room->name = strdup(TITLE_UNHOLY); room->description = strdup(DESC_UNHOLY); SET_BIT(room->zone->flags, ZONE_LOCKED); REMOVE_BIT(room->room_flags, ROOM_PEACEFUL); }
JsonValue JsonValue::read(const std::string &json, size_t &pos) { read_whitespace(json, pos); if (pos == json.length()) throw JsonException("Unexpected end of JSON data"); switch (json[pos]) { case '{': return read_object(json, pos); case '[': return read_array(json, pos); case '"': return read_string(json, pos); case '-': case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': return read_number(json, pos); case 'f': case 't': return read_boolean(json, pos); default: throw JsonException("Unexpected character in JSON data"); } }
ctache_data_t *data_from_json(const char *file_name) { ctache_data_t *data; FILE *fp; struct json_parser *parser; struct json_token *tok; data = NULL; fp = fopen(file_name, "r"); if (fp == NULL) { return NULL; } parser = json_parse_file(fp); tok = json_next_token(parser); if (tok->type == JSON_BRACE_LEFT) { data = read_object(parser); } else { fprintf(stderr, "Bad JSON data\n"); return NULL; } fclose(fp); return data; }
struct obj_data * Obj_from_store(struct obj_file_elem object, int *locate) { struct obj_data *obj; int j; if (real_object(object.item_number) > -1) { obj = read_object(object.item_number, VNUMBER); *locate = (int) object.locate; GET_OBJ_VAL(obj, 0) = object.value[0]; GET_OBJ_VAL(obj, 1) = object.value[1]; GET_OBJ_VAL(obj, 2) = object.value[2]; GET_OBJ_VAL(obj, 3) = object.value[3]; GET_OBJ_VAL(obj, 4) = object.value[4]; GET_OBJ_VAL(obj, 5) = object.value[5]; GET_OBJ_VAL(obj, 6) = object.value[6]; GET_OBJ_VAL(obj, 7) = object.value[7]; GET_OBJ_VAL(obj, 8) = object.value[8]; GET_OBJ_VAL(obj, 9) = object.value[9]; GET_OBJ_EXTRA(obj) = object.extra_flags; GET_OBJ_WEIGHT(obj) = object.weight; GET_OBJ_TIMER(obj) = object.timer; obj->obj_flags.bitvector = object.bitvector; for (j = 0; j < MAX_OBJ_AFFECT; j++) obj->affected[j] = object.affected[j]; return obj; } else return NULL; }
int loadObjects(resource_mgr_t *resmgr) { int i; int *classes, class_count; int positions[1000]; if (objects_init(resmgr)) { #ifdef SCRIPT_DEBUG perror("objects_init"); #endif return 1; } classes = vocabulary_get_classes(resmgr, &class_count); for (i = 0; i < 1000; i++) positions[i] = 0; for (i = 0; i < class_count; i++) { #ifdef SCRIPT_DEBUG printf("\n\nReading class 0x%02X\n", i); #endif if (read_class(resmgr, classes[i], positions) == 0) { #ifdef SCRIPT_DEBUG fprintf(stderr, "Failed to load class %d, which is a parent.\n", i); #endif return 1; } } for (i = 0; i < 1000; i++) positions[i] = 0; for (i = 0; i < 1000; i++) while (read_object(resmgr, i, positions)); object_map = fobjects.data; max_object = fobjects.used; return 0; }
int main(int argc, char *argv[]) { FILE *inf; wave_object_t obj; const size_t NUM_FRAMES = 360; RtInt md = 4; scene_info_t scene; double rad = 20; double t = 0.0; double dt = 2.0*PI/(NUM_FRAMES-1); size_t fnum; if (argc <3) { printf("No input and output file names given!\n"); return 1; } inf = fopen(argv[1], "rt"); if (inf == NULL) { printf("Could not open \"%s\"\n", argv[1]); return 1; } init_object(&obj); read_object(inf, &obj); printf("Object file has:\n %zu vertices\n %zu normals\n %zu texture coordinates\n %zu faces\n %d objects\n", obj.num_verts, obj.num_norms, obj.num_texts, obj.num_faces, 1); RiBegin(RI_NULL); RiOption("trace", "maxdepth", &md, RI_NULL); RiSides(2); scene.cam.location[0] = rad; scene.cam.location[1] = rad; scene.cam.location[2] = rad; scene.cam.look_at[0]= 0.0; scene.cam.look_at[1]= 0.0; scene.cam.look_at[2]= 0.0; scene.cam.roll = 0.0; scene.fprefix = argv[2]; for (fnum = 0; fnum < NUM_FRAMES; ++fnum) { scene.cam.location[0] = rad * sin(t); scene.cam.location[2] = rad * cos(t); t += dt; printf("Rendering frame %lu\n", fnum); doFrame(fnum, &scene, &obj); } RiEnd(); free_object(&obj); fclose(inf); return 0; }
/*prototipo: int getBucket(char *srvName,char *dirName,char *idBucket) *objetivo: Retorna um Bucket, de um Diretorio e Servidor especificados nos parametros de entrada*/ int ss_get_bucket(char *srvName,char *dirName,char *idBucket,BUCKET_T *buff_bucket,int* hit){ uint64_t len_bucket; time_t mtime; char path[PATH_SIZE+1]; *buff_bucket = NULL; *hit = 0; //0 sem cache 1 com cache snprintf(path,PATH_SIZE,"%s %s %s",srvName,dirName,idBucket); //cria um contexto de io no ceph, associando ao Pool que faz o papel de servidor state = set_server(cluster,srvName,&ioctx); if(state >= 0){ /*se o contexto for criado seta o diretorio *(associa uma chave ao contexto para influenciar o hash)*/ state = set_directory(dirName,&ioctx); /*obtem o tamanho do bucket e a data de modficacao *sera utilizado na leitura do bucket e para alocar memoria quando nao obtiver cache*/ state = get_object_size(ioctx, idBucket, &len_bucket, &mtime); if(state < 0){ fprintf(stderr,"[get_bucket/iceph.c] Bucket não localizado!\n"); destroy_ioctx(&ioctx); return 1; } }else{ fprintf(stderr,"[get_bucket/iceph.c] Servidor não localizado!\n"); destroy_ioctx(&ioctx); return 1; } /*busca no cache o Bucket desejado, se nao encontrar *requisita no sistema de armazenamento e disponibiliza no cache*/ *hit = get_buffer(idBucket,buff_bucket); if(*hit == 0){ //o bucket ainda nao foi para o buffer /*se tiver cache disponivel registra o bucket no cache *apos a execucao buff_bucket aponta para a area disponivel*/ *hit = put_buffer(idBucket,path,buff_bucket); if(*hit == 0) //se nao tiver cache disponivel aloca individual *buff_bucket = (BUCKET_T) xmalloc(len_bucket); //busca o bucket no sistema de armazenamento state = read_object(ioctx,idBucket,*buff_bucket,len_bucket,0,0); //IF TEMPORARIO APENAS DEBUG if(*hit == 1) fprintf(stdout,"[get_bucket/iceph.c] cache:\n"); else fprintf(stdout,"[get_bucket/iceph.c] no cache:\n"); }else //APENAS DEBUG fprintf(stdout,"[get_bucket/iceph.c] cache:\n"); destroy_ioctx(&ioctx); return ( (state >= 0) ? 0 : 1); }
static bool read_collection(SerdReader* reader, ReadContext ctx, Ref* dest) { eat_byte_safe(reader, '('); bool end = peek_delim(reader, ')'); *dest = end ? reader->rdf_nil : blank_id(reader); if (ctx.subject) { // subject predicate _:head *ctx.flags |= (end ? 0 : SERD_LIST_O_BEGIN); TRY_RET(emit_statement(reader, ctx, *dest, 0, 0)); *ctx.flags |= SERD_LIST_CONT; } else { *ctx.flags |= (end ? 0 : SERD_LIST_S_BEGIN); } if (end) { return end_collection(reader, ctx, 0, 0, true); } /* The order of node allocation here is necessarily not in stack order, so we create two nodes and recycle them throughout. */ Ref n1 = push_node_padded(reader, genid_size(reader), SERD_BLANK, "", 0); Ref n2 = 0; Ref node = n1; Ref rest = 0; ctx.subject = *dest; while (!(end = peek_delim(reader, ')'))) { // _:node rdf:first object ctx.predicate = reader->rdf_first; bool ate_dot = false; if (!read_object(reader, ctx, &ate_dot) || ate_dot) { return end_collection(reader, ctx, n1, n2, false); } if (!(end = peek_delim(reader, ')'))) { /* Give rest a new ID. Done as late as possible to ensure it is used and > IDs generated by read_object above. */ if (!rest) { rest = n2 = blank_id(reader); // First pass, push } else { set_blank_id(reader, rest, genid_size(reader)); } } // _:node rdf:rest _:rest *ctx.flags |= SERD_LIST_CONT; ctx.predicate = reader->rdf_rest; TRY_RET(emit_statement(reader, ctx, (end ? reader->rdf_nil : rest), 0, 0)); ctx.subject = rest; // _:node = _:rest rest = node; // _:rest = (old)_:node node = ctx.subject; // invariant } return end_collection(reader, ctx, n1, n2, true); }
/*prototipo: int get_lock(char *srvName,char *dirName,char *idBucket,BUCKET_T *buffer) *objetivo: verificar se o servidor que ira executar operacao de escrita adquiriu o lock ou nao*/ int get_lock(char *srvName,char *dirName,char *idBucket,BUCKET_T *buffer){ char lock_flag; BUCKET_T header; char lock_owner[SRVNAME_SIZE]; int locked; lock_flag = ' '; locked = 0; header = *buffer; memset(lock_owner,'\0',SRVNAME_SIZE); /*utilizar check_locked() para verifcar se o servidor ja adquiriu o lock se ele ja tiver adquirido lock, locked vai retornar 1 e lock_owner vai retornar o nome do servidor*/ state = check_locked(idBucket,srvName,&locked,lock_owner); /*somente sera requerido lock se nao houver lock no bufffer se o buffer ja tiver bloqueado pelo proprio servidor que esta pedindo vai retornar 1 permitindo a operacao de escrita*/ if((state == 1) && (locked == 0) && (strlen(lock_owner) == 0) ){ // conecta-se ao pool/servidor state = set_server(cluster,srvName,&ioctx); if(state < 0){ fprintf(stderr,"[get_lock/iceph.c] Servidor não localizado!\n"); return 1; } //seta o diretorio state = set_directory(dirName,&ioctx); if(state >= 0){ state = read_object(ioctx,idBucket,&lock_flag,LOCK_FLAG_SIZE,0,0); if(state >= 0){ if(lock_flag == '0'){ lock_flag = '1'; //altera o flag em disco state = write_object(ioctx,idBucket,&lock_flag,LOCK_FLAG_SIZE,0,0); if(state >= 0){ //altera no buffer *(header+LCKFLAG_OFFSET) = lock_flag; //altera o parametro locked no buffer_pool state = set_locked(idBucket,srvName,lock_flag); } }else return 0; }else return 0; //retorna 0 pois nao conseguir escrever no bucket }else{ fprintf(stderr,"[get_lock/iceph.c] Diretório não localizado!\n"); return 0; } header = NULL; }else if((state == 1) && (locked == 1)) return 1; //srvName ja adquiriu o lock neste buffer return 1; }
int read_object(FILE *fp, object *obj) { int cnt, error=0; int temp; otag *op; otag **prev; object *tobj; char str[10]; fscanf(fp, "%s", str); if (strcmp(str, "#begobj")) return(1); read_object_basic(fp, &temp, obj); fscanf(fp, "%s", str); if (strcmp(str, "#endobj")) return(1); obj->first_obj = 0; obj->parent_obj = 0; obj->parent_rom = 0; obj->parent_crt = 0; if(obj->shotscur > obj->shotsmax) obj->shotscur = obj->shotsmax; /* get # of objects to read in */ read_int(fp, &cnt); prev = &obj->first_obj; while(cnt > 0) { cnt--; op = (otag *)malloc(sizeof(otag)); if(op) { tobj = (object *)malloc(sizeof(object)); if(tobj) { if(read_object(fp, tobj) == -1) error = 1; tobj->parent_obj = obj; op->obj = tobj; op->next_tag = 0; *prev = op; prev = &op->next_tag; } else merror("read_obj", FATAL); } else merror("read_obj", FATAL); } if(error) return(-11); else return(temp); }
internal cont_p repl2(cont_p cont) { object_p scan_obj = cont->args_locals[0]; object_p obj; obj = read_object(&scan_obj->scanner); CP_CALL2(cont, scm_eval, global_env, obj, repl3); }
static void event_scatter_goodies_zone(int rnum, struct room_data *rp, struct event_goodies *stuff) { int i = 0; int exit_found = 0; int gold = 0; struct char_data *monster = NULL; struct obj_data *object = NULL; struct obj_data *coins = NULL; if (DEBUG > 1) log_info("called %s with %d, %08zx, %08zx", __PRETTY_FUNCTION__, rnum, (size_t) rp, (size_t) stuff); if (!rp || rp->number < stuff->bottom || rp->number > stuff->top) return; if (IS_SET(rp->room_flags, (NO_MOB | PEACEFUL | PRIVATE))) return; exit_found = 0; for (i = 0; i < MAX_NUM_EXITS; i++) /* neswud */ if (rp->dir_option[i]) { exit_found = 1; break; } if (!exit_found) return; if (number(0, 99) >= stuff->chance) return; gold = dice(stuff->gold_dice, stuff->gold_die) + stuff->gold_mod; gold_count += gold; coins = create_money(gold); obj_to_room(coins, rnum); rprintf(rnum, "In a brilliant green flash, a pile of %s appears before you!\r\n", coins->short_description); if (number(0, 99) < stuff->mob_chance) { i = number(1, stuff->mob_count) - 1; if ((monster = read_mobile(stuff->mob_vnum[i], VIRTUAL))) { GET_GOLD(monster) = 0; mob_count++; char_to_room(monster, rnum); act("A rift of red light rips open and $N rushes out!", FALSE, monster, 0, monster, TO_ROOM); } } if (number(0, 99) < stuff->obj_chance) { i = number(1, stuff->obj_count) - 1; if ((object = read_object(stuff->obj_vnum[i], VIRTUAL))) { obj_count++; obj_to_room(object, rnum); rprintf(rnum, "In a shimmering of blue light, %s %s forms!\r\n", SANA(object), object->short_description); } } }
void Crash_listrent(struct char_data * ch, char *name) { FILE *fl; char fname[MAX_INPUT_LENGTH], buf[MAX_STRING_LENGTH]; struct obj_file_elem object; struct obj_data *obj; struct rent_info rent; if (!get_filename(name, fname, CRASH_FILE)) return; if (!(fl = fopen(fname, "rb"))) { sprintf(buf, "%s has no rent file.\r\n", name); send_to_char(buf, ch); return; } sprintf(buf, "%s\r\n", fname); if (!feof(fl)) fread(&rent, sizeof(struct rent_info), 1, fl); switch (rent.rentcode) { case RENT_RENTED: strcat(buf, "Rent\r\n"); break; case RENT_CRASH: strcat(buf, "Crash\r\n"); break; case RENT_CRYO: strcat(buf, "Cryo\r\n"); break; case RENT_TIMEDOUT: case RENT_FORCED: strcat(buf, "TimedOut\r\n"); break; default: strcat(buf, "Undef\r\n"); break; } while (!feof(fl)) { fread(&object, sizeof(struct obj_file_elem), 1, fl); if (ferror(fl)) { fclose(fl); return; } if (!feof(fl)) if (real_object(object.item_number) > -1) { obj = read_object(object.item_number, VNUMBER); sprintf(buf, "%s [%ld] (%5dau) %-20s\r\n", buf, object.item_number, GET_OBJ_RENT(obj), obj->short_description); extract_obj(obj); } } send_to_char(buf, ch); fclose(fl); }
static ctache_data_t *read_object(struct json_parser *parser) { ctache_data_t *data; struct json_token *tok; char *key; ctache_data_t *val; int done = 0; size_t len; data = ctache_data_create_hash(); while (!done) { tok = json_next_token(parser); key = strdup(tok->value.string); tok = json_next_token(parser); if (tok->type != JSON_COLON) { fprintf(stderr, "ERROR: Expected ':'\n"); ctache_data_destroy(data); free(key); return NULL; } tok = json_next_token(parser); if (tok->type == JSON_STRING) { len = strlen(tok->value.string); val = ctache_data_create_string(tok->value.string, len); } else if (tok->type == JSON_BOOLEAN) { val = ctache_data_create_boolean(tok->value.boolean); } else if (tok->type == JSON_BRACE_LEFT) { val = read_object(parser); } else if (tok->type == JSON_BRACKET_LEFT) { val = read_array(parser); } else { fprintf(stderr, "ERROR: Expected value\n"); ctache_data_destroy(data); free(key); return NULL; } ctache_data_hash_table_set(data, key, val); free(key); tok = json_next_token(parser); if (tok->type == JSON_BRACE_RIGHT) { done = 1; } else if (tok->type == JSON_COMMA) { done = 0; } else { fprintf(stderr, "ERROR: Expected '}'\n"); ctache_data_destroy(data); return NULL; } } return data; }
struct obj_data *create_object(int vnum, int dummy) { int r_num; struct obj_data *tobj; if((r_num = real_object(vnum)) < 0) tobj = NULL; else tobj = read_object(r_num, REAL); return(tobj); }
static COMMAND_FUNC( rd_obj ) { Data_Obj *dp; Image_File *ifp; dp=PICK_OBJ( "name of image data object" ); ifp=PICK_IMG_FILE(""); if( dp == NO_OBJ ) return; if( ifp == NO_IMAGE_FILE ) return; read_object(QSP_ARG dp, ifp); }
void stream_reader::read_string_ex(pfc::string_base & p_out,t_size p_bytes,abort_callback & p_abort) { const t_size expBase = 64*1024; if (p_bytes > expBase) { pfc::array_t<char> temp; t_size allocWalk = expBase; t_size done = 0; for(;;) { const t_size target = pfc::min_t(allocWalk, p_bytes); temp.set_size(target); read_object(temp.get_ptr() + done, target - done, p_abort); if (target == p_bytes) break; done = target; allocWalk <<= 1; } p_out.set_string(temp.get_ptr(), p_bytes); } else { pfc::string_buffer buf(p_out, p_bytes); read_object(buf.get_ptr(),p_bytes,p_abort); } }
exprt dereferencet::dereference_rec( const exprt &address, const exprt &offset, const typet &type) { if(address.id()==ID_address_of) { const address_of_exprt &address_of_expr=to_address_of_expr(address); const exprt &object=address_of_expr.object(); return read_object(object, offset, type); } else if(address.id()==ID_typecast) { const typecast_exprt &typecast_expr=to_typecast_expr(address); return dereference_typecast(typecast_expr, offset, type); } else if(address.id()==ID_plus) { // pointer arithmetic if(address.operands().size()<2) throw "plus with less than two operands"; return dereference_plus(address, offset, type); } else if(address.id()==ID_if) { const if_exprt &if_expr=to_if_expr(address); return dereference_if(if_expr, offset, type); } else if(address.id()==ID_constant) { const typet result_type=ns.follow(address.type()).subtype(); // pointer-typed constant if(to_constant_expr(address).get_value()==ID_NULL) // NULL { // we turn this into (type *)0 exprt zero=gen_zero(index_type()); return dereference_rec( typecast_exprt(zero, address.type()), offset, type); } else throw "dereferencet: unexpected pointer constant "+address.pretty(); } else { throw "failed to dereference `"+address.id_string()+"'"; } }
int main(int argc, char *argv[]) { char *cases[] = { /* "(+. 1.1 1.2)", */ /* "(integer->float 123)", */ /* "(& 5 7)", */ /* "'hello", */ /* "-", */ /* "(define a (string->in-port \"abc\"))", */ /* "(read-string-in-port-char a)", */ /* "(+i 1 2)", */ /* "(*i 3 4)", */ /* "(quotient 10 3)", */ /* "(remainder 10 3)", */ /* "(= 1 2)", */ /* "(> 4 5)", */ /* "(& 5 7)", */ /* "(| 5 7)", */ /* "(~ 5)", */ /* "(eq? 'hello 'hello)", */ /* "(eq? 1 1)", */ /* "(eq? (string->symbol \"hello\") 'hello)", */ /* "(type-of 'hello)", */ /* "type-of", */ /* "#\\a", */ /* "(type-of #\\a)", */ /* "(define a #(1 2 3))", */ /* "#\\汉", */ /* "(set! a 123)", */ "(string-ref \"汉字\" 0)", }; init_impl(); /* printf("Address of `-': %p\n", &primitive_procs[1]); */ for (int i = 0; i < sizeof(cases) / sizeof(char *); i++) { FILE *stream = fmemopen(cases[i], strlen(cases[i]), "r"); sexp in_port = make_file_in_port(stream); /* inc_ref_count(in_port); */ printf(">> %s\n=> ", cases[i]); sexp value = read_object(in_port); if (is_eof(value)) break; /* inc_ref_count(input); */ value = eval_object(value, repl_environment); /* if (!is_self_eval(input)) */ /* inc_ref_count(value); */ write_object(value, scm_out_port); putchar('\n'); } /* write_object(make_wstring("汉"), scm_out_port); */ /* trigger_gc(); */ return 0; }
static void event_fill_zone_with_mobs(int rnum, struct room_data *rp, struct event_mob_in_zone *mobs) { int i = 0; int j = 0; int couldbe = 0; int exit_found = FALSE; struct char_data *monster = NULL; struct obj_data *object = NULL; if (DEBUG > 1) log_info("called %s with %d, %08zx, %08zx", __PRETTY_FUNCTION__, rnum, (size_t) rp, (size_t) mobs); if (!rp || rp->number < mobs->bottom || rp->number > mobs->top) return; if (IS_SET(rp->room_flags, (NO_MOB | PEACEFUL | PRIVATE))) return; exit_found = 0; for (i = 0; i < MAX_NUM_EXITS; i++) /* neswud */ if (rp->dir_option[i]) { exit_found = 1; break; } if (!exit_found) return; couldbe = number(mobs->atleast, mobs->atmost); for (j = 0; j < couldbe; j++) { if (number(0, 99) >= mobs->chance) continue; i = number(1, mobs->count) - 1; if (!(monster = read_mobile(mobs->mobset[i].vnum, VIRTUAL))) continue; monster->points.max_hit = dice(mobs->mobset[i].hp_dice, mobs->mobset[i].hp_die) + mobs->mobset[i].hp_mod; GET_HIT(monster) = GET_MAX_HIT(monster); GET_EXP(monster) = (dice(mobs->mobset[i].exp_dice, mobs->mobset[i].exp_die) + mobs->mobset[i].exp_mod) * GET_MAX_HIT(monster); GET_GOLD(monster) = number(mobs->mobset[i].gold_dice, mobs->mobset[i].gold_die) + mobs->mobset[i].gold_mod; if (mobs->mobset[i].obj_vnum >= 0) { if (number(0, 99) < mobs->mobset[i].obj_chance) { if ((object = read_object(mobs->mobset[i].obj_vnum, VIRTUAL))) obj_to_char(object, monster); } } char_to_room(monster, rnum); mob_count++; act("In a shimmering column of blue light, $N appears!", FALSE, monster, 0, monster, TO_ROOM); } }
ReaderObject ReaderMapping::read_object(const char* key) const { if (!m_impl) { return {}; } { ReaderObject result; read_object(key, result); return result; } }
int main(int argc, char *argv[]) { init_impl(); char *cases[] = { /* "1", */ /* "12.3", */ /* "123.45", */ /* "1234.567", */ /* "12345.6789", */ /* ";;\n987654.3210", */ /* "+i", */ /* "'hello", */ /* "#\\汉", */ /* "(if #t 1 2)", */ /* "(set! a 1)", */ /* "(begin (set! a 1) a)", */ /* "(begin \"doc\" (write \"Hello, world\") 2)", */ /* "(lambda (x) (+i x 1))", */ /* "(+i 1 1)", */ /* "(eq? \"abc\" \"abc\")", */ /* "(eq? #\\a #\\a)", */ /* "((lambda (x . y) (cons x y)) 1 2 3 4)", */ /* "(eq? 'hello 'hello)", */ /* "(cdr '(1 2))", */ /* "(string-ref \"汉\" 0)", */ /* "(string-length \"汉字\")", */ /* "(string-set! \"汉字\" 1 #\\语)", */ /* "(eval '(cdr '(1 2 3)) (repl-environment))", */ /* "(cons 1 2)", */ /* "#(1 2 3)", */ /* "(+i 1 2)", */ /* "(-i 1 2)", */ /* "(*i 1 2)", */ /* "(/i 1 2)", */ "not", }; for (int i = 0; i < sizeof(cases) / sizeof(char *); i++) { FILE *fp = fmemopen(cases[i], strlen(cases[i]), "r"); lisp_object_t in_port = make_file_in_port(fp); printf(">> %s\n", cases[i]); lisp_object_t compiled_code = compile_as_fn(read_object(in_port), repl_environment); /* port_format(scm_out_port, "-- %*\n", compiled_code); */ lisp_object_t value = run_compiled_code(compiled_code, repl_environment, vm_stack); port_format(scm_out_port, "=> %*\n", value); fclose(fp); } port_format(scm_out_port, "%*\n", vm_stack); return 0; }
void SDLReader::read_sdl(Scene &scene, string file_object, string file_camera, string file_light, string file_plane) { Camera *camera = read_camera(file_camera); scene.set_camera(camera); Material *material; Light *light = read_light(file_light, &material, scene); scene.add_light(light); Mesh *mesh = read_object(file_object, material); scene.add_mesh(mesh); if(file_plane.size() == 0) return; Plane *plane = read_plane(file_plane); scene.set_plane(plane); }
static ctache_data_t *read_array(struct json_parser *parser) { ctache_data_t *data; ctache_data_t *elem; struct json_token *tok; char *str; size_t str_len; int done; data = ctache_data_create_array(0); if (data == NULL) { return NULL; } done = 0; while (!done) { elem = NULL; tok = json_next_token(parser); if (tok->type == JSON_BRACKET_RIGHT) { done = 1; } else if (tok->type == JSON_STRING) { str = tok->value.string; str_len = strlen(str); elem = ctache_data_create_string(str, str_len); } else if (tok->type == JSON_BRACE_LEFT) { elem = read_object(parser); } else { fprintf(stderr, "ERROR: Expected value\n"); ctache_data_destroy(data); return NULL; } if (elem != NULL) { ctache_data_array_append(data, elem); } tok = json_next_token(parser); if (tok->type != JSON_COMMA && tok->type != JSON_BRACKET_RIGHT) { fprintf(stderr, "ERROR: Expected ']' or ','\n"); ctache_data_destroy(data); return NULL; } if (tok->type == JSON_BRACKET_RIGHT) { done = 1; } } return data; }
int pray_for_items(struct char_data *ch, int cmd, char *arg) { char buf[256]; int key_room, gold; bool found; struct obj_data *tmp_obj, *obj; struct extra_descr_data *ext; if (cmd != 176) /* You must pray to get the stuff */ return FALSE; key_room = 1+ch->in_room; strcpy(buf, "item_for_"); strcat(buf, GET_NAME(ch)); gold = 0; found = FALSE; for (tmp_obj = world[key_room].contents; tmp_obj; tmp_obj = tmp_obj->next_content) for(ext = tmp_obj->ex_description; ext; ext = ext->next) if (str_cmp(buf, ext->keyword) == 0) { if (gold == 0) { gold = 1; act("$n kneels and at the altar and chants a prayer to Odin.", FALSE, ch, 0, 0, TO_ROOM); act("You notice a faint light in Odin's eye.", FALSE, ch, 0, 0, TO_CHAR); } obj = read_object(tmp_obj->item_number, REAL); obj_to_room(obj, ch->in_room); act("$p slowly fades into existence.",FALSE,ch,obj,0,TO_ROOM); act("$p slowly fades into existence.",FALSE,ch,obj,0,TO_CHAR); gold += obj->obj_flags.cost; found = TRUE; } if (found) { GET_GOLD(ch) -= gold; GET_GOLD(ch) = MAX(0, GET_GOLD(ch)); return TRUE; } return FALSE; }
int save_state::load_from_file(int thread, int steady_iter, void (*read_object)(object_write_buffer *)) { object_write_buffer *buf = new object_write_buffer(); char fname[256]; sprintf(fname, "%s%d.%d", PATH, thread, steady_iter); //fprintf(stderr,"thread: %d file: %s\n", thread, fname); int fd = open(fname, O_RDONLY); if (fd == -1) { perror("load_checkpoint"); return -1; } netsocket file_sock(fd); int count = 0; for (;;) { char tmp[4]; int retval = file_sock.read_chunk(tmp, 4); if (retval == -1) break; buf->write(tmp, 4); count += 4; //fprintf(stderr,"read data (4 bytes)\n"); } if (debugging) { fprintf(stderr,"thread: %d file: %s size: %d bytes\n", thread, fname, count); } close(fd); buf->set_read_offset(0); read_object(buf); delete buf; return 0; }