自学教程：C++ write_int32函数代码示例

static void jl_serialize_module(ios_t *s, jl_module_t *m){    // set on every startup; don't save    jl_sym_t *jhsym = jl_symbol("JULIA_HOME");    writetag(s, jl_module_type);    jl_serialize_value(s, m->name);    jl_serialize_value(s, m->parent);    size_t i;    void **table = m->bindings.table;    for(i=1; i < m->bindings.size; i+=2) {        if (table[i] != HT_NOTFOUND &&            !(table[i-1] == jhsym && m == jl_core_module)) {            jl_binding_t *b = (jl_binding_t*)table[i];            if (!(b->owner != m && m == jl_main_module)) {                jl_serialize_value(s, b->name);                jl_serialize_value(s, b->value);                jl_serialize_value(s, b->type);                jl_serialize_value(s, b->owner);                write_int8(s, (b->constp<<2) | (b->exportp<<1) | (b->imported));            }        }    }    jl_serialize_value(s, NULL);    if (m == jl_main_module) {        write_int32(s, 1);        jl_serialize_value(s, (jl_value_t*)jl_core_module);    }    else {        write_int32(s, m->usings.len);        for(i=0; i < m->usings.len; i++) {            jl_serialize_value(s, (jl_value_t*)m->usings.items[i]);        }    }}

int32_t process_test_message(struct mile_message_header* msg_head,		struct data_buffer* rbuf, struct data_buffer* sbuf) {	int32_t result_code = MILE_RETURN_SUCCESS;	MEM_POOL_PTR mem_pool;	switch (msg_head->message_type) {	case MT_TEST_REQ_ECHO: // echo message for testing.	{		mem_pool = mem_pool_init(MB_SIZE);		const char *str = read_cstring(rbuf, mem_pool);		log_debug("get echo message [%s]", str);		write_int32(0, sbuf);		write_int8(msg_head->version_major, sbuf);		write_int8(msg_head->version_minor, sbuf);		write_int16(MT_TEST_RES_ECHO, sbuf);		write_int32(msg_head->message_id, sbuf);		write_int32(strlen(str), sbuf);		write_bytes((uint8_t *) str, strlen(str), sbuf);		fill_int32(sbuf->data_len, sbuf, 0);		result_code = MILE_RETURN_SUCCESS;		mem_pool_destroy(mem_pool);	}		break;	default:		result_code = -1;		break;	}	return result_code;}

struct data_buffer* gen_stat_packet(char* cmd,uint8_t* type,MEM_POOL* mem_pool){	char* table_name = NULL;	char* token = NULL;	uint32_t tblen;		if((table_name = strtok(NULL," ")) == NULL) 		return NULL;	tblen = strlen(table_name);	if((token = strtok(NULL," ")) == NULL)		return NULL;	*type = atoi(token);	struct data_buffer *dbuf = init_data_buffer();	size_t data_len = tblen +  5 * sizeof(uint8_t) + MESSAGE_HEAD_LEN + 2*sizeof(uint32_t);	databuf_resize(dbuf, data_len);		//写入数据长度	write_int32(data_len,dbuf);	write_int8(1, dbuf);	write_int8(1, dbuf);	write_int16(MT_CD_STAT, dbuf);	write_int32(0, dbuf);	//timeout	write_int32(0, dbuf);	//拼接协议包	write_int32(tblen,dbuf);	write_bytes((uint8_t*)table_name,tblen,dbuf);	write_int8(*type,dbuf);	return dbuf;}

/*	1 string cursor_id	return string package */static intop_kill(lua_State *L) {	size_t cursor_len = 0;	const char * cursor_id = luaL_tolstring(L, 1, &cursor_len);	if (cursor_len != 8) {		return luaL_error(L, "Invalid cursor id");	}	struct buffer buf;	buffer_create(&buf);	int len = reserve_length(&buf);	write_int32(&buf, 0);	write_int32(&buf, 0);	write_int32(&buf, OP_KILL_CURSORS);	write_int32(&buf, 0);	write_int32(&buf, 1);	write_bytes(&buf, cursor_id, 8);	write_length(&buf, buf.size, len);	lua_pushlstring(L, (const char *)buf.ptr, buf.size);	buffer_destroy(&buf);	return 1;}

struct data_buffer* gen_set_load_threshold_packet(char* cmd,MEM_POOL* mem_pool){	struct data_buffer *dbuf = init_data_buffer();	size_t data_len = MESSAGE_HEAD_LEN + 2*sizeof(uint32_t) + sizeof(double);	databuf_resize(dbuf, data_len);		//写入数据长度	write_int32(data_len,dbuf);	write_int8(1, dbuf);	write_int8(1, dbuf);	write_int16(MT_CD_EXE_SET_LOAD_THRESHOLD, dbuf);	write_int32(0, dbuf);	//timeout	write_int32(0, dbuf);	char *value_str = strtok(NULL, " ");	if (!value_str)		return NULL;	double value = atof(value_str);	write_bytes((uint8_t *)&value, sizeof(value), dbuf);	return dbuf;}

/*	1 string collection	2 integer single remove	3 document selector	return string package */static intop_delete(lua_State *L) {	document selector  = lua_touserdata(L,3);	if (selector == NULL) {		luaL_error(L, "Invalid param");	}	size_t sz = 0;	const char * name = luaL_checklstring(L,1,&sz);	luaL_Buffer b;	luaL_buffinit(L,&b);	struct buffer buf;	buffer_create(&buf);		int len = reserve_length(&buf);		write_int32(&buf, 0);		write_int32(&buf, 0);		write_int32(&buf, OP_DELETE);		write_int32(&buf, 0);		write_string(&buf, name, sz);		write_int32(&buf, lua_tointeger(L,2));		int32_t selector_len = get_length(selector);		int total = buf.size + selector_len;		write_length(&buf, total, len);		luaL_addlstring(&b, (const char *)buf.ptr, buf.size);	buffer_destroy(&buf);	luaL_addlstring(&b, (const char *)selector, selector_len);	luaL_pushresult(&b);	return 1;}

/*	1 integer id	2 string collection	3 integer number	4 cursor_id (8 bytes string/ 64bit)	return string package */static intop_get_more(lua_State *L) {	int id = luaL_checkinteger(L, 1);	size_t sz = 0;	const char * name = luaL_checklstring(L,2,&sz);	int number = luaL_checkinteger(L, 3);	size_t cursor_len = 0;	const char * cursor_id = luaL_tolstring(L, 4, &cursor_len);	if (cursor_len != 8) {		return luaL_error(L, "Invalid cursor id");	}	struct buffer buf;	buffer_create(&buf);		int len = reserve_length(&buf);		write_int32(&buf, id);		write_int32(&buf, 0);		write_int32(&buf, OP_GET_MORE);		write_int32(&buf, 0);		write_string(&buf, name, sz);		write_int32(&buf, number);		write_bytes(&buf, cursor_id, 8);		write_length(&buf, buf.size, len);		lua_pushlstring(L, (const char *)buf.ptr, buf.size);	buffer_destroy(&buf);	return 1;}

void test_compress(FILE* outFp, FILE* inpFp){    LZ4_stream_t lz4Stream_body = { 0 };    LZ4_stream_t* lz4Stream = &lz4Stream_body;    static char inpBuf[RING_BUFFER_BYTES];    int inpOffset = 0;    for(;;) {        // Read random length ([1,MESSAGE_MAX_BYTES]) data to the ring buffer.        char* const inpPtr = &inpBuf[inpOffset];        const int randomLength = (rand() % MESSAGE_MAX_BYTES) + 1;        const int inpBytes = (int) read_bin(inpFp, inpPtr, randomLength);        if (0 == inpBytes) break;        {            char cmpBuf[LZ4_COMPRESSBOUND(MESSAGE_MAX_BYTES)];            const int cmpBytes = LZ4_compress_continue(lz4Stream, inpPtr, cmpBuf, inpBytes);            if(cmpBytes <= 0) break;            write_int32(outFp, cmpBytes);            write_bin(outFp, cmpBuf, cmpBytes);            inpOffset += inpBytes;            // Wraparound the ringbuffer offset            if(inpOffset >= RING_BUFFER_BYTES - MESSAGE_MAX_BYTES) inpOffset = 0;        }    }    write_int32(outFp, 0);}

void test_compress(file* outfp, file* inpfp){    lz4_streamhc_t lz4stream_body = { 0 };    lz4_streamhc_t* lz4stream = &lz4stream_body;    static char inpbuf[ring_buffer_bytes];    int inpoffset = 0;    for(;;)    {        // read random length ([1,message_max_bytes]) data to the ring buffer.        char* const inpptr = &inpbuf[inpoffset];        const int randomlength = (rand() % message_max_bytes) + 1;        const int inpbytes = (int) read_bin(inpfp, inpptr, randomlength);        if (0 == inpbytes) break;        {            char cmpbuf[lz4_compressbound(message_max_bytes)];            const int cmpbytes = lz4_compresshc_continue(lz4stream, inpptr, cmpbuf, inpbytes);            if(cmpbytes <= 0) break;            write_int32(outfp, cmpbytes);            write_bin(outfp, cmpbuf, cmpbytes);            inpoffset += inpbytes;            // wraparound the ringbuffer offset            if(inpoffset >= ring_buffer_bytes - message_max_bytes)                inpoffset = 0;        }    }    write_int32(outfp, 0);}

struct data_buffer* gen_ensure_index_packet(char* cmd,MEM_POOL* mem_pool){	char* table_name = NULL;	char* field_name = NULL;	uint32_t tblen;	uint32_t fdlen;	char* token;	enum index_key_alg index_type;	enum field_types data_type;		if((table_name = strtok(NULL," ")) == NULL) 		return NULL;		if((field_name = strtok(NULL," ")) == NULL) 		return NULL;	if((token = strtok(NULL," ")) == NULL)		return NULL;	index_type = (index_key_alg)atoi(token);	if(index_type > 0xff)		return NULL;	if((token = strtok(NULL," ")) == NULL)		return NULL;	data_type = (enum field_types)atoi(token);	if(data_type > 0xff)		return NULL;	tblen = strlen(table_name);	fdlen = strlen(field_name);	struct data_buffer *dbuf = init_data_buffer();	size_t data_len = tblen + fdlen + 10 * sizeof(uint8_t) + MESSAGE_HEAD_LEN + 2*sizeof(uint32_t);	databuf_resize(dbuf, data_len);	//写入数据长度	write_int32(data_len,dbuf);	write_int8(1, dbuf);	write_int8(1, dbuf);	write_int16(MT_CD_EXE_INDEX, dbuf);	write_int32(0, dbuf);	//timeout	write_int32(0, dbuf);	//拼接协议包	write_int32(tblen,dbuf);	write_bytes((uint8_t*)table_name,tblen,dbuf);		write_int32(fdlen,dbuf);	write_bytes((uint8_t*)field_name,fdlen,dbuf);	write_int8(index_type,dbuf);	write_int8(data_type,dbuf);	return dbuf;}

bool JArchivePrivate::write_header() {	qint32 version_number=JARCHIVE_VERSION;	qint32 header_size=4*3;	qint32 code=JARCHIVE_BEGIN_FILE_CODE;		write_int32(code); //4	write_int32(header_size); //4	write_int32(version_number); //4	return true;}

static void avi_writer_write_stream_format(AviWriter *self) {    avi_writer_push_chunk(self, "strf");    /* This is a BITMAPINFO structure for video streams */    /* BITMAPINFOHEADER size */    write_int32(self->file, 0x28);    /* width and height */    write_int32(self->file, self->width);    write_int32(self->file, self->height);    /* Number of planes, "must be set to 1" */    write_int16(self->file, 1);    /* bits per pixel */    write_int16(self->file, 24);    /* compression */    write_int32(self->file, 0);    /* size, in bytes, of the image */    write_int32(self->file, self->width * self->height * 3);    /* horizontal/vertical pixels per meter (75 dpi) */    write_int32(self->file, 2952);    write_int32(self->file, 2952);    /* Color table size and number of important colors */    write_int32(self->file, 0);    write_int32(self->file, 0);    avi_writer_pop_chunk(self);}

static void jl_serialize_fptr(ios_t *s, void *fptr){    void **pbp = ptrhash_bp(&fptr_to_id, fptr);    if (*pbp == HT_NOTFOUND)        jl_error("unknown function pointer");    write_int32(s, *(ptrint_t*)pbp);}

intbson_encoder_append_int(bson_encoder_t encoder, const char *name, int64_t value){	bool result;	CODER_CHECK(encoder);	/* use the smallest encoding that will hold the value */	if (value == (int32_t)value) {		debug("encoding %lld as int32", value);		result = write_int8(encoder, BSON_INT32) ||			 write_name(encoder, name) ||			 write_int32(encoder, value);	} else {		debug("encoding %lld as int64", value);		result = write_int8(encoder, BSON_INT64) ||			 write_name(encoder, name) ||			 write_int64(encoder, value);	}	if (result) {		CODER_KILL(encoder, "write error on BSON_INT");	}	return 0;}

void avi_writer_close (AviWriter *self) {    avi_writer_pop_chunk(self);     /* Close the "movi" list */    avi_writer_write_index(self);    avi_writer_pop_chunk(self);     /* Close the "AVI" chunk */    /* At this point, there should be no more open chunks */    g_assert(self->chunk_stack == NULL);    /* Fix up frame count and stream length */    fseek(self->file, self->frame_count_offset, SEEK_SET);    write_int32(self->file, self->frame_count);    fseek(self->file, self->length_offset, SEEK_SET);    write_int32(self->file, self->frame_count * self->frame_rate * RATE_SCALE);    fclose(self->file);    g_queue_free(self->index_queue);}

static bool write_grammar_symbol(IOStream *ios, SymbolRef *ref){    switch (ref->type)    {    case SYM_NONE:        return write_int32(ios, 0);    case SYM_TERMINAL:        return write_int32(ios, -1 - ref->index);    case SYM_NONTERMINAL:        return write_int32(ios,  1 + ref->index);    default:        assert(false);    }}

static bool write_MOD_chunk(IOStream *ios, size_t chunk_size){    int init_func = -1;    const void *init_idx;    if (ST_find(&st_functions, "initialize", &init_idx))        init_func = (long)init_idx;    return        chunk_begin(ios, "MOD ", chunk_size) &&        write_int16(ios, 0x0100) &&  /* file version: 1.0 */        write_int16(ios, 0) &&       /* reserved */        write_int32(ios, AR_size(&ar_vars)) &&        write_int32(ios, num_entities) &&        write_int32(ios, AR_size(&ar_properties)) &&        write_int32(ios, init_func) &&        chunk_end(ios, chunk_size);}

struct data_buffer* gen_load_packet(char* cmd,MEM_POOL* mem_pool){	char* table_name = NULL;	char* segment_dir = NULL;	char* token = NULL;	uint32_t tblen;	uint32_t dirlen;	uint16_t sid;		if((table_name = strtok(NULL," ")) == NULL) 		return NULL;	tblen = strlen(table_name);	if((token = strtok(NULL," ")) == NULL)		return NULL;	sid = atoi(token);	if((segment_dir = strtok(NULL," ")) == NULL) 		return NULL;	dirlen = strlen(segment_dir);	struct data_buffer *dbuf = init_data_buffer();	size_t data_len = tblen + dirlen + 10 * sizeof(uint8_t) + MESSAGE_HEAD_LEN + 2*sizeof(uint32_t);	databuf_resize(dbuf, data_len);		//写入数据长度	write_int32(data_len,dbuf);	write_int8(1, dbuf);	write_int8(1, dbuf);	write_int16(MT_CD_EXE_LOAD, dbuf);	write_int32(0, dbuf);	//timeout	write_int32(0, dbuf);	//拼接协议包	write_int32(tblen,dbuf);	write_bytes((uint8_t*)table_name,tblen,dbuf);		write_int16(sid,dbuf);	write_int32(dirlen,dbuf);	write_bytes((uint8_t*)segment_dir,dirlen,dbuf);	return dbuf;}

static void jl_serialize_tag_type(ios_t *s, jl_value_t *v){    if (jl_is_struct_type(v)) {        writetag(s, (jl_value_t*)jl_struct_kind);        jl_serialize_value(s, jl_struct_kind);        write_uint16(s, jl_tuple_len(((jl_struct_type_t*)v)->names));        write_int32(s, ((jl_struct_type_t*)v)->uid);        write_int32(s, ((jl_struct_type_t*)v)->size);        write_int32(s, ((jl_struct_type_t*)v)->alignment);        size_t nf = jl_tuple_len(((jl_struct_type_t*)v)->names);        ios_write(s, (char*)&((jl_struct_type_t*)v)->fields[0], nf*sizeof(jl_fielddesc_t));        jl_serialize_value(s, ((jl_struct_type_t*)v)->name);        jl_serialize_value(s, ((jl_struct_type_t*)v)->parameters);        jl_serialize_value(s, ((jl_struct_type_t*)v)->super);        jl_serialize_value(s, ((jl_struct_type_t*)v)->names);        jl_serialize_value(s, ((jl_struct_type_t*)v)->types);        jl_serialize_value(s, ((jl_struct_type_t*)v)->ctor_factory);        jl_serialize_value(s, ((jl_struct_type_t*)v)->env);        jl_serialize_value(s, ((jl_struct_type_t*)v)->linfo);        jl_serialize_fptr(s, ((jl_struct_type_t*)v)->fptr);    }    else if (jl_is_bits_type(v)) {        writetag(s, jl_struct_kind);        jl_serialize_value(s, jl_bits_kind);        if (v == (jl_value_t*)jl_int32_type)            write_uint8(s, 2);        else if (v == (jl_value_t*)jl_bool_type)            write_uint8(s, 3);        else if (v == (jl_value_t*)jl_int64_type)            write_uint8(s, 4);        else            write_uint8(s, 0);        jl_serialize_value(s, ((jl_tag_type_t*)v)->name);        jl_serialize_value(s, ((jl_bits_type_t*)v)->parameters);        write_int32(s, ((jl_bits_type_t*)v)->nbits);        jl_serialize_value(s, ((jl_bits_type_t*)v)->super);        write_int32(s, ((jl_bits_type_t*)v)->uid);    }    else {        assert(jl_is_tag_type(v));        writetag(s, jl_tag_kind);        jl_serialize_value(s, ((jl_tag_type_t*)v)->name);        jl_serialize_value(s, ((jl_tag_type_t*)v)->parameters);        jl_serialize_value(s, ((jl_tag_type_t*)v)->super);    }}

static void g_convert_int16_to_int32(t_wav_int16 const * p_sample_buffer,t_wav_uint8 * p_output,t_wav_uint32 p_sample_count){    t_wav_uint32 n;    for(n=0; n<p_sample_count; n++)    {        write_int32(p_output,(t_wav_int32) p_sample_buffer[n] << 16 );        p_output += 4;    }}

static void g_convert_float32_to_int32(t_wav_float32 const * p_sample_buffer,t_wav_uint8 * p_output,t_wav_uint32 p_sample_count){    t_wav_uint32 n;    for(n=0; n<p_sample_count; n++)    {        write_int32(p_output,(t_wav_int32) ( p_sample_buffer[n] * 0x80000000 ));        p_output += 4;    }}

struct data_buffer* gen_checkpoint_packet(char* cmd,MEM_POOL* mem_pool){	struct data_buffer *dbuf = init_data_buffer();	size_t data_len = MESSAGE_HEAD_LEN + 2*sizeof(uint32_t);	databuf_resize(dbuf, data_len);		//写入数据长度	write_int32(data_len,dbuf);	write_int8(1, dbuf);	write_int8(1, dbuf);	write_int16(MT_CD_EXE_CP, dbuf);	write_int32(0, dbuf);	//timeout	write_int32(0, dbuf);	return dbuf;}

struct data_buffer* gen_get_load_threshold_packet(char* cmd,MEM_POOL* mem_pool){	struct data_buffer *dbuf = init_data_buffer();	size_t data_len = MESSAGE_HEAD_LEN + 2*sizeof(uint32_t);	databuf_resize(dbuf, data_len);		//写入数据长度	write_int32(data_len,dbuf);	write_int8(1, dbuf);	write_int8(1, dbuf);	write_int16(MT_CD_EXE_GET_LOAD_THRESHOLD, dbuf);	write_int32(0, dbuf);	//timeout	write_int32(0, dbuf);	return dbuf;}

static void avi_writer_write_stream_header(AviWriter *self) {    avi_writer_push_chunk(self, "strh");    /* data type: video stream */    write_fourcc(self->file, "vids");    /* data handler (video codec) */    write_fourcc(self->file, "DIB ");    /* flags */    write_int32(self->file, 0);    /* priority */    write_int16(self->file, 1);    /* language */    write_int16(self->file, 0);    /* initial frames */    write_int32(self->file, 0);    /* scale followed by rate. For video streams, (rate/scale) is the frame rate. */    write_int32(self->file, RATE_SCALE);    write_int32(self->file, self->frame_rate * RATE_SCALE);    /* start */    write_int32(self->file, 0);    /* length (we fill this in later) */    self->length_offset = ftell(self->file);    write_int32(self->file, 0);    /* suggested buffer size */    write_int32(self->file, self->width * self->height * 3 + 1024);    /* quality */    write_int32(self->file, 10000);    /* sample size */    write_int32(self->file, 0);    /* frame position and size (left, top, right, bottom) */    write_int16(self->file, 0);    write_int16(self->file, 0);    write_int16(self->file, self->width - 1);    write_int16(self->file, self->height - 1);    avi_writer_pop_chunk(self);}

DLLEXPORTvoid jl_save_system_image(char *fname, char *startscriptname){    jl_gc_collect();    jl_gc_collect();    int en = jl_gc_is_enabled();    jl_gc_disable();    htable_reset(&backref_table, 50000);    ios_t f;    ios_file(&f, fname, 1, 1, 1, 1);    // orphan old Base module if present    jl_base_module = (jl_module_t*)jl_get_global(jl_main_module, jl_symbol("Base"));    // delete cached slow ASCIIString constructor if present    jl_methtable_t *mt = jl_gf_mtable((jl_function_t*)jl_ascii_string_type);    jl_array_t *spec = mt->defs->func->linfo->specializations;    if (spec->length > 0 &&        ((jl_lambda_info_t*)jl_cellref(spec,0))->inferred == 0) {        mt->cache = JL_NULL;        mt->cache_arg1 = JL_NULL;        mt->defs->func->linfo->tfunc = (jl_value_t*)jl_null;        mt->defs->func->linfo->specializations = NULL;    }    jl_idtable_type = jl_get_global(jl_base_module, jl_symbol("ObjectIdDict"));    jl_serialize_value(&f, jl_array_type->env);    jl_serialize_value(&f, jl_main_module);    write_int32(&f, jl_get_t_uid_ctr());    write_int32(&f, jl_get_gs_ctr());    htable_reset(&backref_table, 0);    ios_t ss;    ios_file(&ss, startscriptname, 1, 0, 0, 0);    ios_copyall(&f, &ss);    ios_close(&ss);    ios_putc(0, &f);    ios_close(&f);    if (en) jl_gc_enable();}

/* Writes an IFF chunk header, consisting of a four-byte type identifier,   followed by the 32-bit chunk size (including the chunk header) */static bool chunk_begin(IOStream *ios, const char *type, size_t size){    assert(strlen(type) == 4);    return        write_int8(ios, type[0]) &&        write_int8(ios, type[1]) &&        write_int8(ios, type[2]) &&        write_int8(ios, type[3]) &&        write_int32(ios, (int)size);}

// 1 integer flags// 2 string collection// 3 documents// return string packagestatic intop_insert(lua_State *L) {	size_t sz = 0;	const char * name = luaL_checklstring(L,2,&sz);	int dsz = document_length(L);	luaL_Buffer b;	luaL_buffinit(L, &b);	struct buffer buf;	buffer_create(&buf);		// make package header, don't raise L error		int len = reserve_length(&buf);		write_int32(&buf, 0);		write_int32(&buf, 0);		write_int32(&buf, OP_INSERT);		write_int32(&buf, lua_tointeger(L,1));		write_string(&buf, name, sz);		int total = buf.size + dsz;		write_length(&buf, total, len);		luaL_addlstring(&b, (const char *)buf.ptr, buf.size);	buffer_destroy(&buf);		if (lua_isuserdata(L,3)) {		document doc = lua_touserdata(L,3);		luaL_addlstring(&b, (const char *)doc, get_length(doc));	} else {		int s = lua_rawlen(L, 3);		int i;		for (i=1;i<=s;i++) {			lua_rawgeti(L,3,i);			document doc = lua_touserdata(L,3);			luaL_addlstring(&b, (const char *)doc, get_length(doc));			lua_pop(L,1);		}	}	luaL_pushresult(&b);	return 1;}

/* Write the "idx1" list, using the queued chunk positions from our index FIFO */static void avi_writer_write_index(AviWriter *self){    IndexQueueEntry *current_entry;    avi_writer_push_chunk(self, "idx1");    /* Write all IndexQueueEntry nodes, freeing them as we go */    while ((current_entry = g_queue_pop_head(self->index_queue))) {	write_fourcc(self->file, current_entry->fourcc);	write_int32(self->file, current_entry->flags);	write_int32(self->file, current_entry->offset);	write_int32(self->file, current_entry->size);	g_free(current_entry);    }    avi_writer_pop_chunk(self);}

static bool write_grammar_rule(IOStream *ios, SymbolRefList *rule){    if (!write_int32(ios, rule->nref))        return false;    size_t n;    for (n = 0; n < rule->nref; ++n)        if (!write_grammar_symbol(ios, &rule->refs[n]))            return false;    return true;}