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 int
op_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 int
op_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 int
op_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);
}
int
bson_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;
}
void *spice_marshaller_add_int32(SpiceMarshaller *m, int32_t v)
{
uint8_t *ptr;
ptr = spice_marshaller_reserve_space(m, sizeof(int32_t));
write_int32(ptr, v);
return (void *)ptr;
}
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);
}
DLLEXPORT
void 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 package
static int
op_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;
}
