unsigned long midifile::parse_prop_header (int file_size) { unsigned long result = 0; if ((file_size - m_pos) > (int) sizeof(unsigned long)) { result = read_long(); /* status (new), or tag */ unsigned char status = (result & 0xFF000000) >> 24; if (status == 0xFF) { m_pos -= 3; /* back up to retrench */ unsigned char type = read_byte(); /* get meta type */ if (type == 0x7F) { (void) read_varinum(); /* prop section length */ result = read_long(); /* control tag */ } else { fprintf ( stderr, "Bad status '%x' in proprietary section near offset %x", int(type), m_pos ); } } }
static cDict *unpack_dict(cBuf *buf, Long *buf_pos) { cDict *dict; cList *keys, *values; Int i; keys = unpack_list(buf, buf_pos); values = unpack_list(buf, buf_pos); if (keys->len <= 64) { dict = dict_new(keys, values); list_discard(keys); list_discard(values); return dict; } else { dict = EMALLOC(cDict, 1); dict->keys = keys; dict->values = values; dict->hashtab_size = read_long(buf, buf_pos); dict->links = EMALLOC(Int, dict->hashtab_size); dict->hashtab = EMALLOC(Int, dict->hashtab_size); for (i = 0; i < dict->hashtab_size; i++) { dict->links[i] = read_long(buf, buf_pos); dict->hashtab[i] = read_long(buf, buf_pos); } dict->refs = 1; return dict; } }
static void unpack_methods(cBuf *buf, Long *buf_pos, Obj *obj) { Int i, size; size = read_long(buf, buf_pos); if (size == -1) { obj->methods = NULL; return; } obj->methods = EMALLOC(ObjMethods, 1); obj->methods->size = size; obj->methods->blanks = read_long(buf, buf_pos); obj->methods->hashtab = EMALLOC(Int, obj->methods->size); obj->methods->tab = EMALLOC(struct mptr, obj->methods->size); for (i = 0; i < obj->methods->size; i++) { obj->methods->hashtab[i] = read_long(buf, buf_pos); obj->methods->tab[i].m = unpack_method(buf, buf_pos); if (obj->methods->tab[i].m) obj->methods->tab[i].m->object = obj; obj->methods->tab[i].next = read_long(buf, buf_pos); } unpack_strings(buf, buf_pos, obj); unpack_idents(buf, buf_pos, obj); }
lwObject *lw_object_read(const char *lw_file) { FILE *f = NULL; lwObject *lw_object = NULL; gint32 form_bytes = 0; gint32 read_bytes = 0; /* open file */ f = fopen(lw_file, "rb"); if (f == NULL) { g_warning("can't open file %s", lw_file); return NULL; } /* check for headers */ if (read_long(f) != ID_FORM) { g_warning("file %s is not an IFF file", lw_file); fclose(f); return NULL; } form_bytes = read_long(f); read_bytes += 4; if (read_long(f) != ID_LWOB) { g_warning("file %s is not a LWOB file", lw_file); fclose(f); return NULL; } /* create new lwObject */ lw_object = g_malloc0(sizeof(lwObject)); /* read chunks */ while (read_bytes < form_bytes) { gint32 id = read_long(f); gint32 nbytes = read_long(f); read_bytes += 8 + nbytes + (nbytes%2); switch (id) { case ID_PNTS: read_pnts(f, nbytes, lw_object); break; case ID_POLS: read_pols(f, nbytes, lw_object); break; case ID_SRFS: read_srfs(f, nbytes, lw_object); break; case ID_SURF: read_surf(f, nbytes, lw_object); break; default: fseek(f, nbytes + (nbytes%2), SEEK_CUR); } } fclose(f); return lw_object; }
/* perform_restoreundo(): Pull a state pointer from the undo chain. This returns 0 on success, 1 on failure. Note that if it succeeds, the frameptr, localsbase, and valstackbase registers are invalid; they must be rebuilt from the stack. */ glui32 perform_restoreundo() { dest_t dest; glui32 res, val; glui32 heapsumlen = 0; glui32 *heapsumarr = NULL; if (undo_chain_size == 0 || undo_chain_num == 0) return 1; dest.ismem = TRUE; dest.size = 0; dest.pos = 0; dest.ptr = undo_chain[0]; dest.str = NULL; res = 0; if (res == 0) { res = read_long(&dest, &val); } if (res == 0) { res = read_memstate(&dest, val); } if (res == 0) { res = read_long(&dest, &val); } if (res == 0) { res = read_heapstate(&dest, val, FALSE, &heapsumlen, &heapsumarr); } if (res == 0) { res = read_long(&dest, &val); } if (res == 0) { res = read_stackstate(&dest, val, FALSE); } /* ### really, many of the failure modes of those calls ought to cause fatal errors. The stack or main memory may be damaged now. */ if (res == 0) { if (heapsumarr) res = heap_apply_summary(heapsumlen, heapsumarr); } if (res == 0) { /* It worked. */ if (undo_chain_size > 1) memmove(undo_chain, undo_chain+1, (undo_chain_size-1) * sizeof(unsigned char *)); undo_chain_num -= 1; glulx_free(dest.ptr); dest.ptr = NULL; } else { /* It didn't work. */ dest.ptr = NULL; } return res; }
lwObject *lw_object_read(const char *lw_file) { /* open file */ FILE *f = fopen(lw_file, "rb"); if (f == NULL) { return NULL; } /* check for headers */ if (read_long(f) != ID_FORM) { fclose(f); return NULL; } wxInt32 read_bytes = 0; wxInt32 form_bytes = read_long(f); read_bytes += 4; if (read_long(f) != ID_LWOB) { fclose(f); return NULL; } /* create new lwObject */ lwObject *lw_object = (lwObject*) calloc(sizeof(lwObject),1); /* read chunks */ while (read_bytes < form_bytes) { wxInt32 id = read_long(f); wxInt32 nbytes = read_long(f); read_bytes += 8 + nbytes + (nbytes%2); switch (id) { case ID_PNTS: read_pnts(f, nbytes, lw_object); break; case ID_POLS: read_pols(f, nbytes, lw_object); break; case ID_SRFS: read_srfs(f, nbytes, lw_object); break; case ID_SURF: read_surf(f, nbytes, lw_object); break; default: fseek(f, nbytes + (nbytes%2), SEEK_CUR); } } fclose(f); return lw_object; }
static void unpack_idents(cBuf *buf, Long *buf_pos, Obj *obj) { Int i; obj->methods->idents_size = read_long(buf, buf_pos); obj->methods->num_idents = read_long(buf, buf_pos); obj->methods->idents = EMALLOC(Ident_entry, obj->methods->idents_size); for (i = 0; i < obj->methods->num_idents; i++) { obj->methods->idents[i].id = read_ident(buf, buf_pos); if (obj->methods->idents[i].id != NOT_AN_IDENT) obj->methods->idents[i].refs = read_long(buf, buf_pos); } }
gint lw_is_lwobject(const char *lw_file) { FILE *f = osgDB::fopen(lw_file, "rb"); if (f) { gint32 form = read_long(f); gint32 nlen = read_long(f); gint32 lwob = read_long(f); fclose(f); if (form == ID_FORM && nlen != 0 && lwob == ID_LWOB) return TRUE; } return FALSE; }
bool lw_is_lwobject(const char *lw_file) { FILE *f = fopen(lw_file, "rb"); if (f) { wxInt32 form = read_long(f); wxInt32 nlen = read_long(f); wxInt32 lwob = read_long(f); fclose(f); if (form == ID_FORM && nlen != 0 && lwob == ID_LWOB) return true; } return false; }
void SendMBINBuffers (EmbMBINChannel* mbinChannel) { register EmbQueue *gthQ = mbinChannel->guestToHostQueue; register EmbQueue *gthrQ = mbinChannel->guestToHostReturnQueue; EmbPtr bufferPtr; struct rm_aligned_pkt *buffer; struct rm_pkt pkt; unsigned int nBytes, id; int historyID; if (mbinChannel->header.messageChannel->guestToHostImpulse) switch (mbinChannel->header.messageChannel->guestToHostImpulse) { case EmbMBINImpulseShutdown: activeMBINChannel = NULL; ResetIncomingQueue (gthQ); ResetOutgoingQueue (gthrQ); ResetIncomingQueue (mbinChannel->hostToGuestSupplyQueue); ResetOutgoingQueue (mbinChannel->hostToGuestQueue); mbinChannel->header.messageChannel->guestToHostImpulse = EmbMessageImpulseNone; UnthreadMessageChannel (mbinChannel->header.messageChannel); free (mbinChannel); return; default: mbinChannel->header.messageChannel->guestToHostImpulse = EmbMessageImpulseNone; break; } while (EmbQueueFilled (gthQ)) { if (0 == EmbQueueSpace (gthrQ)) { SignalLater (gthQ->signal); return; } bufferPtr = EmbQueueTakeWord (gthQ); if (bufferPtr && (bufferPtr != NullEmbPtr) && mbin_sinValid) { buffer = (struct rm_aligned_pkt*) HostPointer (bufferPtr); nBytes = read_long(&buffer->rm_operand[0]) & 0xFFFFFF; memcpy (&pkt.rm_id[0], &buffer->rm_id[0], REMOTE_MEMORY_ALIGNED_PACKET_HEADER); memcpy (&pkt.data[0], &buffer->data[0], nBytes); if (rm_ack == buffer->rm_opcode) { id = read_long(&buffer->rm_id[0]); historyID = id & 0xF; MBINHistory[historyID].id = id; MBINHistory[historyID].acked = TRUE; } spy_transmit(&pkt, REMOTE_MEMORY_PACKET_HEADER + nBytes, &mbin_sin); } EmbQueuePutWord (gthrQ, bufferPtr); } }
Ident read_ident(cBuf *buf, Long *buf_pos) { Int len; Char *s; Ident id; /* Read the length of the identifier. */ len = read_long(buf, buf_pos); /* If the length is -1, it's not really an identifier, but a -1 signalling * a blank variable or method. */ if (len == NOT_AN_IDENT) return NOT_AN_IDENT; /* Otherwise, it's an identifier. Read it into temporary storage. */ s = TMALLOC(Char, len + 1); MEMCPY(s, &(buf->s[*buf_pos]), len); (*buf_pos) += len; s[len] = 0; /* Get the index for the identifier and free the temporary memory. */ id = ident_get(s); tfree_chars(s); return id; }
static void read_surf(FILE *f, int nbytes, lwObject *lwo) { int i; char name[LW_MAX_NAME_LEN]; lwMaterial *material = NULL; /* read surface name */ nbytes -= read_string(f,name); /* find material */ for (i=0; i< lwo->material_cnt; i++) { if (strcmp(lwo->material[i].name,name) == 0) { material = &lwo->material[i]; break; } } /* read values */ while (nbytes > 0) { int id = read_long(f); int len = read_short(f); nbytes -= 6 + len + (len%2); switch (id) { case ID_COLR: material->r = read_char(f) / 255.0; material->g = read_char(f) / 255.0; material->b = read_char(f) / 255.0; read_char(f); /* dummy */ break; default: fseek(f, len+(len%2), SEEK_CUR); } } }
int test_qtostr(testspec_t *t, FILE *ofp) { mp_rat in[2]; long radix; mp_result res, len; if(!parse_rat_values(t, in, NULL, NULL)) return imath_errno = MP_BADARG, 0; trim_line(t->input[1]); if(!read_long(&radix, t->input[1])) return imath_errno = MP_BADARG, 0; if(radix < MP_MIN_RADIX || radix > MP_MAX_RADIX) { fprintf(stderr, "Line %d: Radix %ld out of range\n", t->line, radix); return imath_errno = MP_RANGE, 0; } trim_line(t->output[0]); len = mp_rat_string_len(in[0], radix); if((res = mp_rat_to_string(in[0], radix, g_output, len)) != MP_OK) return imath_errno = res, 0; if(strcmp(t->output[0], g_output) != 0) return imath_errno = OTHER_ERROR, 0; return 1; }
int main(int argc, char **argv) { printf("utf_view " VERSION "\n\n"); CHECK_ERROR(argc != 2 && argc != 3, "Incorrect program usage\n\nusage: utf_tab file [offset]"); long offset = 0; if (argc == 3) { offset = read_long(argv[2]); } /* open file */ FILE *infile = fopen(argv[1], "rb"); CHECK_ERRNO(!infile, "fopen"); /* get file size */ CHECK_ERRNO(fseek(infile, 0 , SEEK_END) != 0, "fseek"); long file_length = ftell(infile); CHECK_ERRNO(file_length == -1, "ftell"); rewind(infile); analyze(infile, offset, file_length); exit(EXIT_SUCCESS); }
ucell load_dictionary(const char *data, ucell len) { u32 checksum=0; const char *checksum_walk; ucell *walk, *reloc_table; dictionary_header_t *header=(dictionary_header_t *)data; /* assertions */ if (len <= (sizeof(dictionary_header_t)) || strncmp(DICTID, data, 8)) return 0; #ifdef CONFIG_DEBUG_DICTIONARY dump_header(header); #endif checksum_walk=data; while (checksum_walk<data+len) { checksum+=read_long(checksum_walk); checksum_walk+=sizeof(u32); } if(checksum) { printk("Checksum invalid (%08x)!\n", checksum); return 0; } data += sizeof(dictionary_header_t); dicthead = target_long(header->length); memcpy(dict, data, dicthead); reloc_table=(ucell *)(data+dicthead); #ifdef CONFIG_DEBUG_DICTIONARY printk("\nmoving dictionary (%x bytes) to %x\n", (ucell)dicthead, (ucell)dict); printk("\ndynamic relocation..."); #endif for (walk = (ucell *) dict; walk < (ucell *) (dict + dicthead); walk++) { int pos, bit, l; l=(walk-(ucell *)dict); pos=l/BITS; bit=l&~(-BITS); if (reloc_table[pos] & target_ucell((ucell)1ULL << bit)) { // printk("%lx, pos %x, bit %d\n",*walk, pos, bit); write_ucell(walk, read_ucell(walk)+pointer2cell(dict)); } } #ifdef CONFIG_DEBUG_DICTIONARY printk(" done.\n"); #endif last = (ucell *)(dict + target_ucell(header->last)); return -1; }
int read_object_basic(FILE *fp, int *index, object *obj) { int i; char str[10]; /* begin of object data */ read_int(fp, index); /* object # */ read_chars(fp, obj->name, sizeof(obj->name)); read_chars(fp, obj->description, sizeof(obj->description)); for (i = 0; i != 3; i++) read_chars(fp, obj->key[i], sizeof(obj->key[i])); read_chars(fp, obj->use_output, sizeof(obj->use_output)); read_long(fp, &obj->value); read_short(fp, &obj->weight); read_char(fp, &obj->type); read_char(fp, &obj->adjustment); read_short(fp, &obj->shotsmax); read_short(fp, &obj->shotscur); read_short(fp, &obj->ndice); read_short(fp, &obj->sdice); read_short(fp, &obj->pdice); read_char(fp, &obj->armor); read_char(fp, &obj->wearflag); read_char(fp, &obj->magicpower); read_char(fp, &obj->magicrealm); read_short(fp, &obj->special); read_chars(fp, obj->flags, sizeof(obj->flags)); read_char(fp, &obj->questnum); read_char(fp,&obj->strength); read_char(fp,&obj->dexterity); read_char(fp,&obj->constitution); read_char(fp,&obj->intelligence); read_char(fp,&obj->piety); for (i = 0; i != 16; i++) read_short(fp, &obj->sets_flag[i]); read_short(fp,&obj->special1); read_long(fp,&obj->special2); /* end of object data */ return(0); }
void unpack_handled (cBuf *buf, Long *buf_pos, cData *d) { HandledFrob *h=TMALLOC(HandledFrob, 1); h->cclass = read_long(buf, buf_pos); unpack_data (buf, buf_pos, &h->rep); h->handler = read_ident(buf, buf_pos); d->u.instance = (void*) h; }
static void unpack_strings(cBuf *buf, Long *buf_pos, Obj *obj) { Int i; Long size; size = read_long(buf, buf_pos); if (size != -1) { #if 1 obj->methods->strings = string_tab_new_with_size(size); obj->methods->strings->tab_num = read_long(buf, buf_pos); obj->methods->strings->blanks = read_long(buf, buf_pos); for (i = 0; i < size; i++) { obj->methods->strings->hashtab[i] = read_long(buf, buf_pos); obj->methods->strings->tab[i].next = read_long(buf, buf_pos); obj->methods->strings->tab[i].hash = read_long(buf, buf_pos); obj->methods->strings->tab[i].refs = read_long(buf, buf_pos); } for (i = 0; i < obj->methods->strings->tab_size; i++) { obj->methods->strings->tab[i].str = string_unpack(buf, buf_pos); } #else Long last_blank = -1; // caused 3 crashes on TEC, disabling code until problem can be determined obj->methods->strings = string_tab_new_with_size(size); obj->methods->strings->tab_size = size; obj->methods->strings->blanks = 0; for (i = 0; i < size; i++) { obj->methods->strings->tab[i].str = string_unpack(buf, buf_pos); if (obj->methods->strings->tab[i].str) { obj->methods->strings->tab_num++; obj->methods->strings->tab[i].hash = read_long(buf, buf_pos); obj->methods->strings->tab[i].refs = read_long(buf, buf_pos); if (obj->methods->strings->blanks == i) { obj->methods->strings->blanks = i+1; last_blank = i+1; } } else { if (last_blank != -1) obj->methods->strings->tab[last_blank].next = i; last_blank = i; } } string_tab_fixup_hashtab(obj->methods->strings, obj->methods->strings->tab_size); #endif } else { obj->methods->strings = string_tab_new(); } }
int test_qtodec(testspec_t *t, FILE *ofp) { mp_rat in[4]; long radix, prec; mp_round_mode rmode; mp_result res, expect = MP_OK, len; if(!parse_rat_values(t, in, NULL, NULL)) return imath_errno = MP_BADARG, 0; if(t->output[0][0] == '$' && !parse_result_code(t->output[0], &expect)) { fprintf(stderr, "Line %d: Invalid result code [%s]\n", t->line, t->output[0]); return 0; } trim_line(t->input[1]); trim_line(t->input[2]); trim_line(t->input[3]); if(!read_long(&radix, t->input[1])) return imath_errno = MP_BADARG, 0; if(!read_long(&prec, t->input[2])) return imath_errno = MP_BADARG, 0; if(!read_long((long *)&rmode, t->input[3])) return imath_errno = MP_BADARG, 0; if(prec < 0) { fprintf(stderr, "Line %d: Precision %ld out of range\n", t->line, prec); return imath_errno = MP_RANGE, 0; } trim_line(t->output[0]); len = mp_rat_decimal_len(in[0], radix, prec); if((res = mp_rat_to_decimal(in[0], radix, prec, rmode, g_output, len)) != expect) return imath_errno = res, 0; if(res == MP_OK && strcmp(t->output[0], g_output) != 0) return imath_errno = OTHER_ERROR, 0; return 1; }
main() { char **tokenv; char *s; int tokenc; int i; prompt(); for ( s=read_long(); s!=NULL; s=read_long() ) { tokenv=tokenize(s,&tokenc); if (!no_token(tokenv)) /* if there is a token */ { check_for_exit(tokenv); do_fork(tokenv,&tokenc); } prompt(); } }
static void unpack_vars(cBuf *buf, Long *buf_pos, Obj *obj) { Int i; obj->vars.size = read_long(buf, buf_pos); obj->vars.blanks = read_long(buf, buf_pos); obj->vars.hashtab = EMALLOC(Int, obj->vars.size); obj->vars.tab = EMALLOC(Var, obj->vars.size); for (i = 0; i < obj->vars.size; i++) { obj->vars.hashtab[i] = read_long(buf, buf_pos); obj->vars.tab[i].name = read_ident(buf, buf_pos); if (obj->vars.tab[i].name != NOT_AN_IDENT) { obj->vars.tab[i].cclass = read_long(buf, buf_pos); unpack_data(buf, buf_pos, &obj->vars.tab[i].val); } obj->vars.tab[i].next = read_long(buf, buf_pos); } }
static int next_chunk (struct png* png) { // printf ("%s:%d\n", __FUNCTION__, png->ib); if (png->ib) png->ib += 8 + png->c.length + 4; else png->ib = 8; /* Skip MAGIC */ // printf ("%s: %d %d\n", __FUNCTION__, png->ib, png->cb); if (png->ib >= png->cb) return -1; png->c.length = read_long (png->pb + png->ib); memcpy (&png->c.id, &png->pb[png->ib + 4], 4); return 0; }
static void read_file(t_env *env, int fd) { long tmp; char *data; while ((tmp = read_long(env)) >= 0) { data = read_mem(env, tmp); tmp = write(fd, data, tmp); free(data); } if (tmp == -2) ft_putendl("ERROR: error while reading file"); else if (tmp == -1) ft_putendl("SUCCESS"); }
static glui32 read_heapstate(dest_t *dest, glui32 chunklen, int portable, glui32 *sumlen, glui32 **summary) { glui32 res, count, lx; glui32 *arr; *sumlen = 0; *summary = NULL; if (chunklen == 0) return 0; /* no heap */ if (!portable) { count = chunklen / sizeof(glui32); arr = glulx_malloc(chunklen); if (!arr) return 1; res = read_buffer(dest, (void *)arr, chunklen); if (res) return res; *sumlen = count; *summary = arr; return 0; } count = chunklen / 4; arr = glulx_malloc(count * sizeof(glui32)); if (!arr) return 1; for (lx=0; lx<count; lx++) { res = read_long(dest, arr+lx); if (res) return res; } *sumlen = count; *summary = arr; return 0; }
static cList *unpack_list(cBuf *buf, Long *buf_pos) { Int len, i; cList *list; cData *d; len = read_long(buf, buf_pos); if (len == -1) { list = NULL; } else { list = list_new(len); d = list_empty_spaces(list, len); for (i = 0; i < len; i++) unpack_data(buf, buf_pos, d++); } return list; }
static void do_the_thing(t_env *env, char **splitted) { char *file; int fd; file = get_file_name(splitted[1]); if ((fd = open(file, O_CREAT | O_TRUNC | O_WRONLY , (int)read_long(env))) == -1) { write_long(env, 0); ft_putendl("ERROR: can't create file"); return ; } write_long(env, 1); read_file(env, fd); close(fd); free(file); }
static int parse_binary(char *str, unsigned char *buf, int limit) { int pos = 0; char *tok; trim_line(str); for(tok = strtok(str, "."); tok != NULL && pos < limit; tok = strtok(NULL, ".")) { long v; if(!read_long(&v, tok) || v > UCHAR_MAX || v < 0) return -1; buf[pos++] = (unsigned char)v; } return pos; }
void command_get(t_env *env, char **splitted) { int res; if (!splitted[1]) { ft_putendl("ERROR: you must specify a file to get"); return ; } write_long(env, COMMAND_GET); write_str(env, splitted[1]); if ((res = read_long(env)) == -1) ft_putendl("ERROR: file not found"); else if (res == -2) ft_putendl("ERROR: permissions denied"); else if (res == -3) ft_putendl("ERROR: unknown error"); else do_the_thing(env, splitted); }
/** * @todo ЗАДОКУМЕНТИРОВАТЬ * @return */ SimpleRedisClient::operator long () const { if(data_size < 1) { printf("SimpleRedisClient::operator long (%u) \n", data_size); return data_size; } if(getData() == 0) { printf("SimpleRedisClient::operator long (%u) \n", data_size); return -1; } int d = 0; int r = read_long(getData(), &d); printf("SimpleRedisClient::operator long (%u|res=%d) \n", data_size, r); return r; }
int main(int argc, char **argv) { printf("utf_view " VERSION "\n\n"); CHECK_ERROR(argc != 2 && argc != 3, "Incorrect program usage\n\nusage: utf_tab file [offset]"); long offset = 0; if (argc == 3) { offset = read_long(argv[2]); } /* open file */ reader_t *infile = open_reader_file(argv[1]); CHECK_ERRNO(!infile, "fopen"); /* get file size */ long file_length = reader_length(infile); analyze(infile, offset, file_length); exit(EXIT_SUCCESS); }