void img_dmap_write(FILE *f, img_dmap_t *dmap) { int count; short int has_uppers; /* Write the identifier */ write_word((u_int32_t *)"DMAP", f); /* Write the width and height */ write_short(&dmap->w, f); write_short(&dmap->h, f); if (dmap->uppers == NULL) has_uppers = 0; else has_uppers = 1; write_short(&has_uppers, f); /* Write the distances */ for (count = 0; count < dmap->w * dmap->h; count++) write_double(&(dmap->dists[count]), f); /* Write each vector */ for (count = 0; count < dmap->w * dmap->h; count++) { write_double(&(Vx(dmap->nns[count])), f); write_double(&(Vy(dmap->nns[count])), f); } if (dmap->uppers != NULL) { for (count = 0; count < dmap->w * dmap->h; count++) { write_short(&Vx(dmap->uppers[count]), f); write_short(&Vy(dmap->uppers[count]), f); } } }
/** * @brief Writes MMC marker. * * @param buffer * @param img */ void write_mcc_marker(type_buffer *buffer, type_mcc *mcc) { int length; int i,j; write_short(buffer, MCC); length=5 + 6 * mcc->count; for(i=0; i<mcc->count; ++i) { length += mcc->data[i].input_count * (1 << mcc->data[i].input_component_type) + mcc->data[i].output_count * ( 1 << mcc->data[i].output_component_type); } write_int(buffer, length); write_byte(buffer, mcc->index); type_mcc_data* data; for(i=0; i<mcc->count; ++i) { data = &mcc->data[i]; write_byte(buffer, data->type); write_short(buffer, data->input_count | ( data->input_component_type << 14)); for(j=0; j<data->input_count * (1 << data->input_component_type); ++j) { write_byte(buffer, data->input_components[j]); } write_short(buffer, data->output_count | ( data->output_component_type << 14)); for(j=0; j<data->output_count * (1 << data->output_component_type); ++j) { write_byte(buffer, data->output_components[j]); } if(data->type & 2) { write_byte(buffer, data->atk | (data->ads << 4)); } else { write_byte(buffer, data->decorrelation_transform_matrix | ( data->deccorelation_transform_offset << 4)); } } }
int BmpWrite::operator=(Image& img) { long BytesPerLine; long BufferSize; int x,y; unsigned char* buffer; if (NULL !=f ) { width = img.Width(); height = img.Height(); BytesPerLine = Align32(width*3); BufferSize = BytesPerLine*height; // Bitmap File Header fwrite("BM",1,2,f); write_long(14+40+BufferSize); write_short(0); write_short(0); write_long(14+40); // DIB Header write_long(40); write_long(width); write_long(height); write_short(1); write_short(24); write_long(0); write_long(BufferSize); write_long(0); write_long(0); write_long(0); write_long(0); // no LUT ; // write pixel data for (y=0;y<height;y++) { for (x=0;x<width;x++) { write_char(img[y][x].Blue()); write_char(img[y][x].Green()); write_char(img[y][x].Red()); buffer +=3; } for (int i=BytesPerLine-3*x;i>0;i--) { write_char(0); } } fclose(f); f = NULL; return 0; } else { return 1; } }
// size in this case is the length of the string to write. void writer_sink::write_string(const TCHAR *s, size_t size) { #ifdef _UNICODE if (m_build_unicode) { bool strEnd = false; TCHAR ch; for (; size ; size--) { if (!strEnd) { ch = *s++; if (ch == _T('\0')) strEnd = true; } write_short(ch); } } else { char *wb = new char[size]; memset(wb, 0, size); WideCharToMultiByte(CP_ACP, 0, s, -1, wb, size, NULL, NULL); write_data(wb, size); delete [] wb; } #else char *wb = new char[size]; memset(wb, 0, size); strncpy(wb, s, size); write_data(wb, size); delete [] wb; #endif }
// size in this case is the length of the string to write. void writer_sink::write_string(const TCHAR *s, size_t size) { #ifdef _UNICODE if (m_ti.is_unicode()) { bool strEnd = false; TCHAR ch = L'\0'; for (; size ; size--) { if (!strEnd) { ch = *s++; if (ch == _T('\0')) strEnd = true; } write_short(ch); } } else { char *wb = new char[size]; memset(wb, 0, size); WideCharToMultiByte(CP_ACP, 0, s, -1, wb, (int)size, NULL, NULL); write_data(wb, size); delete [] wb; } #else //TODO: Why does this allocate memory? It could just write the string and a manual zero character? char *wb = new char[size]; memset(wb, 0, size); strncpy(wb, s, size); write_data(wb, size); delete [] wb; #endif }
static int write_counted_string (unsigned short count, char *string, FILE *file) { if (write_short (count, file) == 0) return 0; if (fwrite (string, (int) sizeof (char), (int) count, file) != count) return 0; return 1; }
int write_object_basic(FILE *fp, int index, object *obj) { int i; /* begin of object data */ write_int(fp, index); /* object # */ printf("Writing object %s\n", obj->name ); write_chars(fp, obj->name, sizeof(obj->name)); write_chars(fp, obj->description, sizeof(obj->description)); for (i = 0; i != 3; i++) write_chars(fp, obj->key[i], sizeof(obj->key[i])); write_chars(fp, obj->use_output, sizeof(obj->use_output)); write_long(fp, obj->value); write_short(fp, obj->weight); write_char(fp, obj->type); write_char(fp, obj->adjustment); write_short(fp, obj->shotsmax); write_short(fp, obj->shotscur); write_short(fp, obj->ndice); write_short(fp, obj->sdice); write_short(fp, obj->pdice); write_char(fp, obj->armor); write_char(fp, obj->wearflag); write_char(fp, obj->magicpower); write_char(fp, obj->magicrealm); write_short(fp, obj->special); write_chars(fp, obj->flags, sizeof(obj->flags)); write_char(fp, obj->questnum); write_char(fp,obj->strength); write_char(fp,obj->dexterity); write_char(fp,obj->constitution); write_char(fp,obj->intelligence); write_char(fp,obj->piety); for (i = 0; i != 16; i++) write_short(fp, obj->sets_flag[i]); write_short(fp,obj->special1); write_long(fp,obj->special2); /* end of object data */ return(0); }
static void write_string (MonoCompile *cfg, const char *str) { size_t len = strnlen (str, 0x2000); write_int (cfg, (int) len); gunichar2 *u = u8to16 (str); for (int i = 0; i < len; i++) write_short (cfg, u[i]); }
void OutPacket::write_string(const std::string& str) { int16_t length = static_cast<int16_t>(str.length()); write_short(length); for (int16_t i = 0; i < length; i++) { write_byte(str[i]); } }
static void write_field(FILE *f, const save_field_t *field, void *base) { void *p = (byte *)base + field->ofs; int i; switch (field->type) { case F_BYTE: write_data(p, field->size, f); break; case F_SHORT: for (i = 0; i < field->size; i++) { write_short(f, ((short *)p)[i]); } break; case F_INT: for (i = 0; i < field->size; i++) { write_int(f, ((int *)p)[i]); } break; case F_FLOAT: for (i = 0; i < field->size; i++) { write_float(f, ((float *)p)[i]); } break; case F_VECTOR: write_vector(f, (vec_t *)p); break; case F_ZSTRING: write_string(f, (char *)p); break; case F_LSTRING: write_string(f, *(char **)p); break; case F_EDICT: write_index(f, *(void **)p, sizeof(edict_t), g_edicts, MAX_EDICTS - 1); break; case F_CLIENT: write_index(f, *(void **)p, sizeof(gclient_t), game.clients, game.maxclients - 1); break; case F_ITEM: write_index(f, *(void **)p, sizeof(gitem_t), itemlist, game.num_items - 1); break; case F_POINTER: write_pointer(f, *(void **)p, field->size); break; default: gi.error("%s: unknown field type", __func__); } }
char * Slot_encode(Slot *slot, size_t *len){ logmsg(LOG_DEBUG, "Encoding slot."); if (slot == NULL){ Slot *emptyslot = Slot_new_empty(); char *data = Slot_encode(emptyslot, len); Slot_free(emptyslot); return data; } char *data; size_t pos = 0; if (Slot_is_empty(slot)){ data = malloc(sizeof(char) * SIZE_SHORT); pos += write_short(slot->id, data + pos); *len = pos; return data; } if (slot->nbt_len == -1){ data = malloc(sizeof(char) * (SIZE_SHORT + SIZE_BYTE + SIZE_SHORT + SIZE_SHORT)); } else { data = malloc(sizeof(char) * (SIZE_SHORT + SIZE_BYTE + SIZE_SHORT + SIZE_SHORT + slot->nbt_len)); } pos += write_short(slot->id, data+pos); pos += write_char(slot->count, data+pos); pos += write_short(slot->damage, data+pos); pos += write_short(slot->nbt_len, data+pos); if (slot->nbt_len != -1){ memcpy(data+pos, slot->nbt, slot->nbt_len); pos += slot->nbt_len; } *len = pos; return data; }
int XauWriteAuth (FILE *auth_file, Xauth *auth) { if (write_short (auth->family, auth_file) == 0) return 0; if (write_counted_string (auth->address_length, auth->address, auth_file) == 0) return 0; if (write_counted_string (auth->number_length, auth->number, auth_file) == 0) return 0; if (write_counted_string (auth->name_length, auth->name, auth_file) == 0) return 0; if (write_counted_string (auth->data_length, auth->data, auth_file) == 0) return 0; return 1; }
/** * @brief Writes MCT marker. * * @param buffer * @param img */ void write_mct_marker(type_buffer *buffer, type_mct *mct) { int length; uint8_t Smct; int i; write_short(buffer, MCT); length = 5 + mct->length*(1<<mct->element_type); write_int(buffer, length); Smct = (mct->element_type << 6); Smct |= (mct->type << 4); Smct |= mct->index; write_byte(buffer, Smct); for(i=0; i<length-5; ++i) { write_byte(buffer, mct->data[i]); } }
static void write_pool (MonoCompile *cfg, ConstantPoolEntry *entry) { if (!entry || !entry->data) { write_byte (cfg, POOL_NULL); return; } short *cp_index = (short *) g_hash_table_lookup (cfg->gdump_ctx->constant_pool, entry); if (cp_index == NULL) add_pool_entry (cfg, entry); else { switch (entry->pt) { case PT_STRING: write_byte (cfg, POOL_STRING); break; case PT_METHOD: write_byte (cfg, POOL_METHOD); break; case PT_ENUMKLASS: write_byte (cfg, POOL_KLASS); break; case PT_KLASS: write_byte (cfg, POOL_KLASS); break; case PT_SIGNATURE: write_byte (cfg, POOL_SIGNATURE); break; case PT_OPTYPE: write_byte (cfg, POOL_NODE_CLASS); break; case PT_INPUTTYPE: write_byte (cfg, POOL_ENUM); break; } write_short (cfg, *cp_index); } }
static glui32 write_stackstate(dest_t *dest, int portable) { glui32 res; glui32 lx; glui32 lastframe; /* If we're storing for the purpose of undo, we don't need to do any byte-swapping, because the result will only be used by this session. */ if (!portable) { res = write_buffer(dest, stack, stackptr); if (res) return res; return 0; } /* Write a portable stack image. To do this, we have to write stack frames in order, bottom to top. Remember that the last word of every stack frame is a pointer to the beginning of that stack frame. (This includes the last frame, because the save opcode pushes on a call stub before it calls perform_save().) */ lastframe = (glui32)(-1); while (1) { glui32 frameend, frm, frm2, frm3; unsigned char loctype, loccount; glui32 numlocals, frlen, locpos; /* Find the next stack frame (after the one in lastframe). Sadly, this requires searching the stack from the top down. We have to do this for *every* frame, which takes N^2 time overall. But save routines usually aren't nested very deep. If it becomes a practical problem, we can build a stack-frame array, which requires dynamic allocation. */ for (frm = stackptr, frameend = stackptr; frm != 0 && (frm2 = Stk4(frm-4)) != lastframe; frameend = frm, frm = frm2) { }; /* Write out the frame. */ frm2 = frm; frlen = Stk4(frm2); frm2 += 4; res = write_long(dest, frlen); if (res) return res; locpos = Stk4(frm2); frm2 += 4; res = write_long(dest, locpos); if (res) return res; frm3 = frm2; numlocals = 0; while (1) { loctype = Stk1(frm2); frm2 += 1; loccount = Stk1(frm2); frm2 += 1; res = write_byte(dest, loctype); if (res) return res; res = write_byte(dest, loccount); if (res) return res; if (loctype == 0 && loccount == 0) break; numlocals++; } if ((numlocals & 1) == 0) { res = write_byte(dest, 0); if (res) return res; res = write_byte(dest, 0); if (res) return res; frm2 += 2; } if (frm2 != frm+locpos) fatal_error("Inconsistent stack frame during save."); /* Write out the locals. */ for (lx=0; lx<numlocals; lx++) { loctype = Stk1(frm3); frm3 += 1; loccount = Stk1(frm3); frm3 += 1; if (loctype == 0 && loccount == 0) break; /* Put in up to 0, 1, or 3 bytes of padding, depending on loctype. */ while (frm2 & (loctype-1)) { res = write_byte(dest, 0); if (res) return res; frm2 += 1; } /* Put in this set of locals. */ switch (loctype) { case 1: do { res = write_byte(dest, Stk1(frm2)); if (res) return res; frm2 += 1; loccount--; } while (loccount); break; case 2: do { res = write_short(dest, Stk2(frm2)); if (res) return res; frm2 += 2; loccount--; } while (loccount); break; case 4: do { res = write_long(dest, Stk4(frm2)); if (res) return res; frm2 += 4; loccount--; } while (loccount); break; } } if (frm2 != frm+frlen) fatal_error("Inconsistent stack frame during save."); while (frm2 < frameend) { res = write_long(dest, Stk4(frm2)); if (res) return res; frm2 += 4; } /* Go on to the next frame. */ if (frameend == stackptr) break; /* All done. */ lastframe = frm; } return 0; }
/* Constructs and queues a request packet describing the http query pointed * to by 'start'. */ int make_request_packet(Server *serv, int fd, int num_chars) { struct sockaddr_in client_name, local_name; int client_namelen, local_namelen; int free_start, free_end; int packet_length; char *request; int len; client_namelen = sizeof(struct sockaddr_in); if (getpeername(fd, (struct sockaddr *) &client_name, &client_namelen) < 0) { syslog(LOG_INFO, "make_request_packet: failed to get peer " "name: %m\n"); return 0; } local_namelen = sizeof(struct sockaddr_in); if (getsockname(fd, (struct sockaddr *) &local_name, &local_namelen) < 0) { syslog(LOG_INFO, "make_request_packet: failed to get sock name: %m\n"); return 0; } change_state(serv, fd, fs_requested_backend); /* locate the free end of the buffer (possibly appending to previous * control packets) */ append_data(serv, serv->control_fd, &free_start, &free_end, fs_output); /* reserve the first 4 bytes of the packet for the size field */ packet_length = PAK_COM_OFF; /* add command field to packet */ serv->writebuf.buffer[free_start + packet_length++] = PAK_REQUEST; /* add unique ID field to packet */ write_long(&serv->writebuf.buffer[free_start], &packet_length, (getpid() & 0xffff) | (fd << 16), 1); /* add client IP field to packet */ write_long(&serv->writebuf.buffer[free_start], &packet_length, client_name.sin_addr.s_addr, 0); /* add local IP field to packet */ write_long(&serv->writebuf.buffer[free_start], &packet_length, local_name.sin_addr.s_addr, 0); /* add local port field to packet */ write_short(&serv->writebuf.buffer[free_start], &packet_length, serv->port, 1); /* write the http headers */ request = &serv->writebuf.buffer[serv->writebuf.pos[fd]]; while (request[0] == '\r' || request[0] == '\n') request++; for (len = 0; len < num_chars && !isspace(request[len]); len++) ; if (len < num_chars) { write_string(&serv->writebuf.buffer[free_start], &packet_length, "method"); write_string_n(&serv->writebuf.buffer[free_start], &packet_length, request, len); num_chars -= len; request += len; for (len = 0; len < num_chars && isspace(request[len]); len++) ; if (len < num_chars) { num_chars -= len; request += len; for (len = 0; request[len] && !isspace(request[len]); len++) ; write_string(&serv->writebuf.buffer[free_start], &packet_length, "uri"); write_string_n(&serv->writebuf.buffer[free_start], &packet_length, request, len); num_chars -= len; request += len; for (len = 0; len < num_chars && isspace(request[len]); len++) ; if (len < num_chars) { num_chars -= len; request += len; for (len = 0; request[len] && !isspace(request[len]); len++) ; write_string(&serv->writebuf.buffer[free_start], &packet_length, "version"); write_string_n(&serv->writebuf.buffer[free_start], &packet_length, request, len); /* each line should end with \r\n. Be a bit lenient, and * allow just \r or \n, too. End of request is indicated * by two such lines in a row */ if (request[len] == '\r') len++; if (request[len] == '\n') len++; num_chars -= len; request += len; /* find "field: value\r\n" on successive lines, adding them * to the buffer as field\0value\0 */ while (num_chars > 0 && request[0] != '\r' && request[0] != '\n') { for (len = 0; len < num_chars && request[len] != ':' && request[len] != '\r' && request[len] != '\n'; len++) ; if (len < num_chars && request[len] == ':') { write_string_n(&serv->writebuf.buffer[free_start], &packet_length, request, len); for (len++; len < num_chars && isspace(request[len]); len++) ; num_chars -= len; request += len; for (len = 0; len < num_chars && request[len] != '\r' && request[len] != '\n'; len++) ; write_string_n(&serv->writebuf.buffer[free_start], &packet_length, request, len); } if (request[len] == '\r') len++; if (request[len] == '\n') len++; num_chars -= len; request += len; } } } } /* set first 4 bytes of packet to the total packet length */ write_long(&serv->writebuf.buffer[free_start], NULL, packet_length, 1); /* add the packet to the output buffer properly */ if (free_end - free_start < packet_length) fatal(serv, "request packet overflowed the buffer\n"); add_data(serv, serv->control_fd, NULL, free_start, packet_length, fs_output); return 1; }
int make_backend_error_packet(Server *serv, int fd, u32 ip, u16 nbo_port) { struct sockaddr_in local_name; struct sockaddr_in remote_name; int local_namelen; int remote_namelen; int packet_length; int free_start, free_end; local_namelen = sizeof(struct sockaddr_in); if (getsockname(fd, (struct sockaddr *) &local_name, &local_namelen) < 0) { syslog(LOG_INFO, "make_backend_error_packet: failed to get sock " "name: %m\n"); return 0; } /* locate the free end of the buffer (possibly appending to previous * control packets) */ append_data(serv, serv->control_fd, &free_start, &free_end, fs_output); packet_length = PAK_COM_OFF; /* write control code */ serv->writebuf.buffer[free_start + packet_length++] = PAK_BE_ERROR; /* write unique id */ write_long(&serv->writebuf.buffer[free_start], &packet_length, (getpid() & 0xffff) | (fd << 16), 1); /* add local IP field to packet */ write_long(&serv->writebuf.buffer[free_start], &packet_length, local_name.sin_addr.s_addr, 0); /* add local port field to packet */ write_short(&serv->writebuf.buffer[free_start], &packet_length, serv->port, 1); if (serv->fd_partner[fd] == -1) { /* the connection failed straight away, so we've still got the ip * and port (already in network byte order) to use */ write_long(&serv->writebuf.buffer[free_start], &packet_length, ip, 0); write_short(&serv->writebuf.buffer[free_start], &packet_length, nbo_port, 0); } else { /* else the partner (which is the failed backend fd) has the ip and * port stored in serv->fd_connection_* */ write_long(&serv->writebuf.buffer[free_start], &packet_length, serv->fd_connection_ip[serv->fd_partner[fd]], 0); write_short(&serv->writebuf.buffer[free_start], &packet_length, serv->fd_connection_port[serv->fd_partner[fd]], 1); } /* add client IP field to packet */ remote_namelen = sizeof(struct sockaddr_in); if (getpeername(fd, (struct sockaddr *) &remote_name, &remote_namelen) == -1) { syslog(LOG_INFO, "make_backend_error_packet: failed to getpeer " "name: %m\n"); return 0; } write_long(&serv->writebuf.buffer[free_start], &packet_length, remote_name.sin_addr.s_addr, 0); /* write length */ write_long(&serv->writebuf.buffer[free_start], NULL, packet_length, 1); /* add the packet to the output buffer properly */ if (free_end - free_start < packet_length) fatal(serv, "unable to fit backend_error packet in static buffer\n"); add_data(serv, serv->control_fd, NULL, free_start, packet_length, fs_output); return 1; }
int write_room(FILE *fp, room *rom) { int i; char perm_only; short cnt; xtag *xp; ctag *cp; otag *op; struct exit_ *exit; perm_only = 0; /* all objects, monsters */ printf("Writing room number %d\n", rom->rom_num ); /* begin of room data */ fprintf(fp, "#begrom\n"); write_short(fp, rom->rom_num); write_chars(fp, rom->name, sizeof(rom->name)); write_char(fp, rom->lolevel); write_char(fp, rom->hilevel); write_short(fp, rom->special); write_char(fp, rom->trap); write_short(fp, rom->trapexit); write_chars(fp, rom->track, sizeof(rom->track)); write_chars(fp, rom->flags, sizeof(rom->flags)); for (i = 0; i != 10; i++) write_short(fp, rom->random[i]); write_char(fp, rom->traffic); for (i = 0; i != 10; i++) write_lasttime(fp, rom->perm_mon[i]); for (i = 0; i != 10; i++) write_lasttime(fp, rom->perm_obj[i]); write_long(fp, rom->beenhere); write_long(fp, rom->established); write_short(fp, rom->death_rom); write_char(fp,rom->zone_type); write_char(fp,rom->zone_subtype); write_char(fp,rom->env_type); write_short(fp,rom->special1); write_long(fp,rom->special2); /* short description */ if(rom->short_desc) { write_short(fp, (short)(strlen(rom->short_desc)+1)); /* # of characters to read in */ write_chars(fp, rom->short_desc, strlen(rom->short_desc)+1); } else { write_short(fp, 0); } /* long description */ if(rom->long_desc) { write_short(fp, (short)(strlen(rom->long_desc)+1)); /* # of characters to read in */ write_chars(fp, rom->long_desc, strlen(rom->long_desc)+1); } else { write_short(fp, 0); } /* object description */ if(rom->obj_desc) { write_short(fp, (short)(strlen(rom->obj_desc)+1)); /* # of characters to read in */ write_chars(fp, rom->obj_desc, strlen(rom->obj_desc)+1); } else { write_short(fp, 0); } /* exits */ cnt = count_ext(rom); write_int(fp, cnt); xp = rom->first_ext; while(xp) { exit = xp->ext; /* write exit structure */ write_chars(fp, exit->name, sizeof(exit->name)); write_short(fp, exit->room); write_chars(fp, exit->flags, sizeof(exit->flags)); write_lasttime(fp, exit->ltime); write_lasttime(fp, exit->random); write_chars(fp, exit->rand_mesg[0], sizeof(exit->rand_mesg[0])); write_chars(fp, exit->rand_mesg[1], sizeof(exit->rand_mesg[1])); write_char(fp, exit->key); /* end exit structure */ xp = xp->next_tag; } /* monsters */ cnt = count_mon(rom, perm_only); write_int(fp, cnt); cp = rom->first_mon; while(cp) { if(!perm_only || (perm_only && cp->crt->flags[0] & 1)) write_creature(fp, -1, cp->crt); cp = cp->next_tag; } /* objects */ cnt = count_ite(rom, perm_only); write_int(fp, cnt); op = rom->first_obj; while(op) { if(!perm_only || (perm_only && op->obj->flags[0] & 1)) write_object(fp, -1, op->obj); op = op->next_tag; } /* end of room data */ fprintf(fp, "#endrom\n"); return(0); }
static void write_instructions (MonoCompile *cfg, int instruction_count) { MonoBasicBlock *bb; write_int (cfg, instruction_count); for (bb = cfg->bb_entry; bb; bb = bb->next_bb) { MonoInst *insn; cfg_debug ("== bb: %d (in: %d, out: %d) ==", bb->block_num, bb->in_count, bb->out_count); for (insn = bb->code; insn; insn = insn->next) { int i; int *id = (int *) g_hash_table_lookup (cfg->gdump_ctx->insn2id, insn); g_assert (id); write_int (cfg, *id); // hardcoded node class: only one input and NUM_SUCCESSOR successors write_pool (cfg, create_cp_entry (cfg, (void *) insn, PT_OPTYPE)); write_byte (cfg, cfg->bb_entry->code != insn); // properties write_short (cfg, 2); // property #1 GString *insndesc = mono_print_ins_index_strbuf (-1, insn); cfg_debug ("dumping node [%2d]: %s", *id, insndesc->str); write_pool (cfg, create_cp_entry (cfg, (void *) "fullname", PT_STRING)); write_byte (cfg, PROPERTY_POOL); write_pool (cfg, create_cp_entry (cfg, (void *) insndesc->str, PT_STRING)); g_string_free (insndesc, TRUE); // property #2 write_pool (cfg, create_cp_entry (cfg, (void *) "category", PT_STRING)); write_byte (cfg, PROPERTY_POOL); if (bb->in_count > 1 && bb->code == insn) write_pool (cfg, create_cp_entry (cfg, (void *) "merge", PT_STRING)); else if (bb->code == insn) write_pool (cfg, create_cp_entry (cfg, (void *) "begin", PT_STRING)); else if (MONO_IS_COND_BRANCH_OP (insn)) write_pool (cfg, create_cp_entry (cfg, (void *) "controlSplit", PT_STRING)); else if (MONO_IS_PHI (insn)) write_pool (cfg, create_cp_entry (cfg, (void *) "phi", PT_STRING)); else if (!MONO_INS_HAS_NO_SIDE_EFFECT (insn)) write_pool (cfg, create_cp_entry (cfg, (void *) "state", PT_STRING)); else write_pool (cfg, create_cp_entry (cfg, (void *) "fixed", PT_STRING)); // end of properties write_int (cfg, -1); // never set predecessor. int *next_id; if (insn->next != NULL) { next_id = (int *) g_hash_table_lookup (cfg->gdump_ctx->insn2id, insn->next); g_assert (next_id); cfg_debug ("\tsuccessor' : [%2d]", *next_id); write_int (cfg, *next_id); for (i = 1; i < NUM_SUCCESSOR; i++) write_int (cfg, -1); } else { g_assert (bb->out_count < NUM_SUCCESSOR); for (i = 0; (i < bb->out_count) && (i < NUM_SUCCESSOR); i++) { if (bb->out_bb[i]->code == NULL) write_int (cfg, -1); else { next_id = (int *) g_hash_table_lookup (cfg->gdump_ctx->insn2id, bb->out_bb[i]->code); if (next_id) cfg_debug ("\tsuccessor'': [%2d]", *next_id); write_int (cfg, next_id ? *next_id : -1); } } for (; i < NUM_SUCCESSOR; i++) write_int (cfg, -1); } } } }
static void add_pool_entry (MonoCompile *cfg, ConstantPoolEntry *entry) { int *cp_id= (int *) mono_mempool_alloc0 (cfg->mempool, sizeof (int)); *cp_id = cfg->gdump_ctx->next_cp_id; g_hash_table_insert (cfg->gdump_ctx->constant_pool, entry, cp_id); write_byte (cfg, POOL_NEW); write_short (cfg, cfg->gdump_ctx->next_cp_id++); switch (entry->pt) { case PT_STRING: write_byte (cfg, POOL_STRING); write_string (cfg, (char *) entry->data); break; case PT_METHOD: { MonoMethod *method = (MonoMethod *) entry->data; write_byte (cfg, POOL_METHOD); write_pool (cfg, create_cp_entry (cfg, (void *) method->klass, PT_KLASS)); write_pool (cfg, create_cp_entry (cfg, (void *) method->name, PT_STRING)); write_pool (cfg, create_cp_entry (cfg, (void *) method->signature, PT_SIGNATURE)); write_int (cfg, (int) method->flags); write_int (cfg, -1); // don't transmit bytecode. break; } case PT_KLASS: { MonoClass *klass = (MonoClass *) entry->data; write_byte (cfg, POOL_KLASS); write_string (cfg, m_class_get_name (klass)); write_byte (cfg, KLASS); break; } case PT_SIGNATURE: { write_byte (cfg, POOL_SIGNATURE); MonoMethodSignature *sig = (MonoMethodSignature *) entry->data; write_short (cfg, sig->param_count); for (int i = 0; i < sig->param_count; i++) { GString *sbuf = g_string_new (NULL); mono_type_get_desc (sbuf, sig->params [i], TRUE); write_pool (cfg, create_cp_entry (cfg, (void *) sbuf->str, PT_STRING)); g_string_free (sbuf, TRUE); } GString *sbuf = g_string_new (NULL); mono_type_get_desc (sbuf, sig->ret, TRUE); write_pool (cfg, create_cp_entry (cfg, (void *) sbuf->str, PT_STRING)); g_string_free (sbuf, TRUE); break; } case PT_OPTYPE: { MonoInst *insn = (MonoInst *) entry->data; write_byte (cfg, POOL_NODE_CLASS); write_string (cfg, mono_inst_name (insn->opcode)); GString *insndesc = mono_print_ins_index_strbuf (-1, insn); int len = strnlen (insndesc->str, 0x2000); #define CUTOFF 40 if (len > CUTOFF) { insndesc->str[CUTOFF] = '\0'; insndesc->str[CUTOFF - 1] = '.'; insndesc->str[CUTOFF - 2] = '.'; } write_string (cfg, insndesc->str); if (len > CUTOFF) insndesc->str[CUTOFF] = ' '; g_string_free (insndesc, TRUE); // one predecessor write_short (cfg, 1); write_byte (cfg, 0); write_pool (cfg, create_cp_entry (cfg, (void *) "predecessor", PT_STRING)); write_pool (cfg, create_cp_entry (cfg, (void *) NULL, PT_INPUTTYPE)); // make NUM_SUCCESSOR successor edges, not everyone will be used. #define NUM_SUCCESSOR 5 write_short (cfg, NUM_SUCCESSOR); for (int i = 0; i < NUM_SUCCESSOR; i++) { char *str = g_strdup ("successor1"); str[9] = '0' + i; write_byte (cfg, 0); write_pool (cfg, create_cp_entry (cfg, (void *) str, PT_STRING)); } break; } case PT_INPUTTYPE: { write_byte (cfg, POOL_ENUM); write_pool (cfg, create_cp_entry (cfg, (void *) NULL, PT_ENUMKLASS)); write_int (cfg, 0); break; } case PT_ENUMKLASS: { write_byte (cfg, POOL_KLASS); write_string (cfg, "InputType"); write_byte (cfg, ENUM_KLASS); write_int (cfg, 1); write_pool (cfg, create_cp_entry (cfg, (void *) "fixed", PT_STRING)); break; } } }
int write_creature_basic(FILE *fp, int index, creature *crt) { int i; printf("Writing creature %s\n", crt->name ); /* begin of creature data */ write_int(fp, index); /* creature # */ write_chars(fp, crt->name, sizeof(crt->name)); write_chars(fp, crt->description, sizeof(crt->description)); write_chars(fp, crt->talk, sizeof(crt->talk)); write_chars(fp, crt->password, sizeof(crt->password)); for (i = 0; i != 3; i++) write_chars(fp, crt->key[i], sizeof(crt->key[i])); write_short(fp, crt->fd); write_char(fp, crt->level); write_char(fp, crt->type); write_char(fp, crt->class); write_char(fp, crt->race); write_char(fp, crt->numwander); write_short(fp, crt->alignment); write_char(fp, crt->strength); write_char(fp, crt->dexterity); write_char(fp, crt->constitution); write_char(fp, crt->intelligence); write_char(fp, crt->piety); write_short(fp, crt->hpmax); write_short(fp, crt->hpcur); write_short(fp, crt->mpmax); write_short(fp, crt->mpcur); write_char(fp, crt->armor); write_char(fp, crt->thaco); write_long(fp, crt->experience); write_long(fp, crt->gold); write_short(fp, crt->ndice); write_short(fp, crt->sdice); write_short(fp, crt->pdice); write_short(fp, crt->special); for (i=0; i != 6; i++) write_long(fp, crt->proficiency[i]); for (i=0; i < 8; i++) write_long(fp, crt->realm[i]); write_chars(fp, crt->spells, sizeof(crt->spells)); write_chars(fp, crt->flags, sizeof(crt->flags)); write_chars(fp, crt->quests, sizeof(crt->quests)); write_char(fp, crt->questnum); for (i=0; i != 10; i++) write_short(fp, crt->carry[i]); write_short(fp, crt->rom_num); for (i=0; i != 10; i++) { write_char(fp, crt->daily[i].max); write_char(fp, crt->daily[i].cur); write_long(fp, crt->daily[i].ltime); } for (i=0; i < 45; i++) write_lasttime(fp, crt->lasttime[i]); write_long(fp,crt->bank_balance); write_chars(fp,crt->title, sizeof(crt->title)); for(i=0; i != 5; i++) write_short(fp, crt->misc_stats[i]); write_short(fp,crt->clanindex); write_long(fp,crt->clanexp); write_char(fp,crt->guildtype); write_long(fp,crt->guildexp); write_short(fp,crt->special1); write_long(fp,crt->special2); /* end of creature data */ return(0); }
// parses the memwatch data format from a string unsigned long long read_string_data(const char* in, void** vdata, void** vmask) { *vdata = NULL; if (vmask) *vmask = NULL; unsigned char** data = (unsigned char**)vdata; unsigned char** mask = (unsigned char**)vmask; int read, chr = 0; int string = 0, unicode_string = 0, comment = 0, multiline_comment = 0, high = 1; int filename = 0, filename_start; unsigned long size = 0; int endian = 0; while (in[0]) { read = 0; // if between // and a newline, don't write to output buffer if (comment) { if (in[0] == '\n') comment = 0; in++; // if between /* and */, don't write to output buffer } else if (multiline_comment) { if (in[0] == '*' && in[1] == '/') { multiline_comment = 0; in++; } in++; // if between quotes, read bytes to output buffer, unescaping } else if (string) { if (in[0] == '\"') string = 0; else if (in[0] == '\\') { // unescape char after a backslash if (!in[1]) return size; if (in[1] == 'n') { write_byte('\n'); } else if (in[1] == 'r') { write_byte('\r'); } else if (in[1] == 't') { write_byte('\t'); } else { write_byte(in[1]); } in++; } else write_byte(in[0]); in++; // if between single quotes, word-expand bytes to output buffer, unescaping } else if (unicode_string) { if (in[0] == '\'') unicode_string = 0; else if (in[0] == '\\') { // unescape char after a backslash if (!in[1]) return size; if (in[1] == 'n') { write_short('\n'); } else if (in[1] == 'r') { write_short('\r'); } else if (in[1] == 't') { write_short('\t'); } else { write_short(in[1]); } if (endian) bswap(&(*data)[size - 2], 2); in++; } else { write_short(in[0]); if (endian) bswap(&(*data)[size - 2], 2); } in++; // if between <>, read a file name, then stick that file into the buffer } else if (filename) { if (in[0] == '>') { filename = 0; write_byte(0); // null-terminate the filename // TODO: support <filename@offset:size> syntax // open the file, read it into the buffer, close the file FILE* f = fopen((char*)(*data + filename_start), "rb"); if (!f) { if (data) free(data); return 0; } fseek(f, 0, SEEK_END); int file_size = ftell(f); size = filename_start + file_size; *data = realloc(*data, size); fseek(f, 0, SEEK_SET); fread((*data + filename_start), 1, file_size, f); fclose(f); } else write_byte(in[0]); in++; // ? is an unknown byte, but only if the caller wants a mask } else if (in[0] == '?' && vmask) { write_blank(); in++; // $ changes the endian-ness } else if (in[0] == '$') { endian = !endian; in++; // # signifies a decimal number } else if (in[0] == '#') { // 8-bit unsigned long long value; in++; if (in[0] == '#') { // 16-bit in++; if (in[0] == '#') { // 32-bit in++; if (in[0] == '#') { // 64-bit in++; expand(8); parse_ull(in, (unsigned long long*)(&((*data)[size - 8])), 0); if (endian) bswap(&((*data)[size - 8]), 8); if (mask) *(unsigned long long*)(&((*mask)[size - 8])) = 0xFFFFFFFFFFFFFFFF; } else { expand(4); parse_ull(in, &value, 0); if (endian) bswap(&value, 4); *(int32_t*)(&((*data)[size - 4])) = value; if (mask) *(uint32_t*)(&((*mask)[size - 4])) = 0xFFFFFFFF; } } else { expand(2); parse_ull(in, &value, 0); if (endian) bswap(&value, 2); *(int16_t*)(&((*data)[size - 2])) = value; if (mask) *(uint16_t*)(&((*mask)[size - 2])) = 0xFFFF; } } else { expand(1); parse_ull(in, &value, 0); *(int8_t*)(&((*data)[size - 1])) = value; if (mask) *(uint8_t*)(&((*mask)[size - 1])) = 0xFF; } if (in[0] == '-') in++; while (isdigit(in[0])) in++; // % is a float, %% is a double } else if (in[0] == '%') { in++; if (in[0] == '%') { in++; expand(8); double* value = (double*)(&((*data)[size - 8])); sscanf(in, "%lf", value); if (endian) bswap(value, 8); if (mask) *(unsigned long long*)(&((*mask)[size - 8])) = 0xFFFFFFFFFFFFFFFF; } else { expand(4); float* value = (float*)(&((*data)[size - 4])); sscanf(in, "%f", value); if (endian) bswap(value, 4); if (mask) *(uint32_t*)(&((*mask)[size - 4])) = 0xFFFFFFFF; } if (in[0] == '-') in++; while (isdigit(in[0]) || (in[0] == '.')) in++; // anything else is a hex digit } else { if ((in[0] >= '0') && (in[0] <= '9')) { read = 1; chr |= (in[0] - '0'); } if ((in[0] >= 'A') && (in[0] <= 'F')) { read = 1; chr |= (in[0] - 'A' + 0x0A); } if ((in[0] >= 'a') && (in[0] <= 'f')) { read = 1; chr |= (in[0] - 'a' + 0x0A); } if (in[0] == '\"') string = 1; if (in[0] == '\'') unicode_string = 1; if (in[0] == '/' && in[1] == '/') comment = 1; if (in[0] == '/' && in[1] == '*') multiline_comment = 1; if (in[0] == '<') { filename = 1; filename_start = size; } in++; } if (read) { if (high) chr = chr << 4; else { write_byte(chr); chr = 0; } high = !high; } } return size; }
void write_lasttime(FILE *fp, struct lasttime lt) { write_long(fp, lt.interval); write_long(fp, lt.ltime); write_short(fp, lt.misc); }
OutPacket::OutPacket(int16_t opcode) { write_short(opcode); }
void OutPacket::write_point(Point<int16_t> position) { write_short(position.x()); write_short(position.y()); }
/* Initialisation du fichier TIFF résultat, avec les paramètres suivants: - width: la largeur de l'image ; - height: la hauteur de l'image ; - row_per_strip: le nombre de lignes de pixels par bande. */ struct tiff_file_desc *init_tiff_file (const char *file_name, uint32_t width, uint32_t height, uint32_t row_per_strip) { FILE *file = NULL; struct tiff_file_desc *tfd = calloc(1, sizeof(struct tiff_file_desc)); uint32_t line_size; if (tfd == NULL) return NULL; /* Allocate & check write_buf */ tfd->row_size = width * 3; tfd->write_buf = malloc(tfd->row_size); if (tfd->write_buf == NULL) return NULL; /* Allocate & check strip_offsets */ tfd->nb_strips = height / row_per_strip; if (height % row_per_strip) tfd->nb_strips++; tfd->strip_offsets = malloc(tfd->nb_strips * sizeof(uint32_t)); if (tfd->strip_offsets == NULL) return NULL; /* Allocate & check strip_bytes */ tfd->strip_bytes = malloc(tfd->nb_strips * sizeof(uint32_t)); if (tfd->strip_bytes == NULL) return NULL; file = fopen(file_name, "wb"); if (file == NULL) return NULL; tfd->file = file; tfd->is_le = true; tfd->width = width; tfd->height = height; tfd->rows_per_strip = row_per_strip; /* Software comment definition */ const char *comment = COMMENT; const uint32_t comment_size = strlen(comment) + 1; /* Header construction */ const uint32_t ifd_offset = 8 + comment_size; const uint16_t entry_count = 13; /* Endianness + TIFF identification */ write_short(tfd, LITTLE_ENDIAN); write_short(tfd, 42); /* IFD offset */ write_long(tfd, ifd_offset); /* Software comment */ fwrite(comment, 1, comment_size, file); uint32_t next = ifd_offset + 2 + 12 * entry_count + 4; /* IFD data */ write_short(tfd, entry_count); /* Image Width */ write_short(tfd, IMAGE_WIDTH); write_short(tfd, LONG); write_long(tfd, 1); write_long(tfd, tfd->width); /* Image Length */ write_short(tfd, IMAGE_LENGTH); write_short(tfd, LONG); write_long(tfd, 1); write_long(tfd, tfd->height); /* BitsPerSample */ write_short(tfd, BITS_PER_SAMPLE); write_short(tfd, SHORT); write_long(tfd, 3); write_long(tfd, next); next += 3 * 2; /* Compression */ write_short(tfd, COMPRESSION); write_short(tfd, SHORT); write_long(tfd, 1); write_long(tfd, 1); /* PhotometricInterpretation */ write_short(tfd, PHOTOMETRIC); write_short(tfd, SHORT); write_long(tfd, 1); write_long(tfd, 2); /* StripOffsets */ write_short(tfd, STRIP_OFFSETS); write_short(tfd, LONG); write_long(tfd, tfd->nb_strips); const uint32_t strips_pos = next + 16; uint32_t line_offset = strips_pos; /* One row handling */ if (tfd->nb_strips > 1) { line_offset += 8 * tfd->nb_strips; write_long(tfd, strips_pos); } else { write_long(tfd, line_offset); tfd->strip_offsets[0] = line_offset; } /* SamplesPerPixel */ write_short(tfd, SAMPLES_PER_PIXEL); write_short(tfd, SHORT); write_long(tfd, 1); write_long(tfd, 3); /* RowsPerStrip */ write_short(tfd, ROWS_PER_STRIP); write_short(tfd, LONG); write_long(tfd, 1); write_long(tfd, tfd->rows_per_strip); /* StripByteCounts */ write_short(tfd, STRIP_BYTE_COUNTS); write_short(tfd, LONG); write_long(tfd, tfd->nb_strips); /* Last line's height */ uint32_t line_height = tfd->height % tfd->rows_per_strip; if (tfd->height > 0 && line_height == 0) line_height = tfd->rows_per_strip; /* One row handling */ if (tfd->nb_strips > 1) { line_size = tfd->rows_per_strip * tfd->width * 3; write_long(tfd, strips_pos + 4 * tfd->nb_strips); } else { line_size = line_height * tfd->width * 3; write_long(tfd, line_size); tfd->strip_bytes[0] = line_size; } /* XResolution */ write_short(tfd, X_RESOLUTION); write_short(tfd, RATIONAL); write_long(tfd, 1); write_long(tfd, next); next += 2 * 4; /* YResolution */ write_short(tfd, Y_RESOLUTION); write_short(tfd, RATIONAL); write_long(tfd, 1); write_long(tfd, next); next += 2 * 4; /* ResolutionUnit */ write_short(tfd, RESOLUTION_UNIT); write_short(tfd, SHORT); write_long(tfd, 1); write_long(tfd, 2); /* Software */ write_short(tfd, SOFTWARE); write_short(tfd, ASCII); write_long(tfd, comment_size); write_long(tfd, 8); /* No other IFD */ write_long(tfd, 0); /* BitsPerSample data */ write_short(tfd, 8); write_short(tfd, 8); write_short(tfd, 8); /* XResolution data */ write_long(tfd, 100); write_long(tfd, 1); /* YResolution data */ write_long(tfd, 100); write_long(tfd, 1); /* Initialize internal writing data */ tfd->current_line = 0; tfd->line_size = line_size; /* Initialize the first MCU position */ tfd->next_pos_mcu = 0; /* If there are multiple strips */ if (tfd->nb_strips > 1) { /* Write all StripOffsets */ for (uint32_t i = 0; i < tfd->nb_strips; i++){ write_long(tfd, line_offset); tfd->strip_offsets[i] = line_offset; line_offset += line_size; } /* StripByteCounts data */ for (uint32_t i = 0; i < tfd->nb_strips - 1; i++) { write_long(tfd, line_size); tfd->strip_bytes[i] = line_size; } /* Last line's size */ line_size = line_height * tfd->width*3; tfd->strip_bytes[tfd->nb_strips-1] = line_size; write_long(tfd, line_size); } return tfd; }
/*{{{ DO_MSG*/ static void DO_MSG( struct share_msg msg, /* message to send */ char *data /* pointer to data */ ) { switch (msg.type & TYPE_MASK) { /*{{{ T_SCREEN*/ case T_SCREEN: write_short(&(msg.type), 1); write_short(&(msg.stuff[0]), 4); if (msg.stuff[3] != 0) write_char(data, bit_size(msg.stuff[1], msg.stuff[2], 1)); break; /*}}} */ /*{{{ T_BLIT*/ case T_BLIT: write_short(&(msg.type), 1); write_short(&(msg.stuff[0]), 8); break; /*}}} */ /*{{{ T_WRITE*/ case T_WRITE: write_short(&(msg.type), 1); write_short(&(msg.stuff[0]), 5); break; /*}}} */ /*{{{ T_LINE*/ case T_LINE: write_short(&(msg.type), 1); write_short(&(msg.stuff[0]), 5); break; /*}}} */ /*{{{ T_DATA*/ case T_DATA: write_short(&(msg.type), 1); write_short(&(msg.stuff[0]), 4); if (msg.stuff[3] != 0) write_char(data, bit_size(msg.stuff[1], msg.stuff[2], 1)); break; /*}}} */ /*{{{ T_NOP*/ case T_NOP: write_short(&(msg.type), 1); if ((msg.type & 0xF) > 0) write_char(data, msg.type & 0xF); /*}}} */ /*{{{ T_POINT*/ case T_POINT: write_short(&(msg.type), 1); write_short(&(msg.stuff[0]), 3); break; /*}}} */ /*{{{ T_TIME*/ case T_TIME: write_short(&(msg.type), 1); write_short(&(msg.stuff[0]), 2); break; /*}}} */ /*{{{ T_KILL*/ case T_KILL: write_short(&(msg.type), 1); write_short(&(msg.stuff[0]), 1); break; /*}}} */ /*{{{ T_BYTESCROLL*/ case T_BYTESCROLL: write_short(&(msg.type), 1); write_short(&(msg.stuff[0]), 6); break; /*}}} */ } }