DLLEXPORT size_t jl_write(uv_stream_t *stream, const char *str, size_t n) { int err; //TODO: BAD!! Needed because Julia can't yet detect null stdio if (stream == 0) return 0; if (stream->type<UV_HANDLE_TYPE_MAX) { //is uv handle if (stream->type == UV_FILE) { JL_SIGATOMIC_BEGIN(); jl_uv_file_t *file = (jl_uv_file_t *)stream; // Do a blocking write for now uv_fs_t req; uv_buf_t buf[1]; buf[0].base = (char*)str; buf[0].len = n; err = uv_fs_write(file->loop, &req, file->file, buf, 1, -1, NULL); JL_SIGATOMIC_END(); return err ? 0 : n; } else { uv_write_t *uvw = (uv_write_t*)malloc(sizeof(uv_write_t)+n); err = jl_write_copy(stream,str,n,uvw, (void*)&jl_uv_writecb); if (err < 0) { free(uvw); return 0; } return n; } } else { ios_t *handle = (ios_t*)stream; return ios_write(handle,str,n); } }
void jl_write_compiler_output(void) { if (!jl_generating_output()) return; if (!jl_options.incremental) jl_precompile(jl_options.compile_enabled == JL_OPTIONS_COMPILE_ALL); if (!jl_module_init_order) { jl_printf(JL_STDERR, "WARNING: --output requested, but no modules defined during run\n"); return; } jl_array_t *worklist = jl_module_init_order; JL_GC_PUSH1(&worklist); jl_module_init_order = jl_alloc_vec_any(0); int i, l = jl_array_len(worklist); for (i = 0; i < l; i++) { jl_value_t *m = jl_arrayref(worklist, i); if (jl_get_global((jl_module_t*)m, jl_symbol("__init__"))) { jl_array_ptr_1d_push(jl_module_init_order, m); } } if (jl_options.incremental) { if (jl_options.outputji) if (jl_save_incremental(jl_options.outputji, worklist)) jl_exit(1); if (jl_options.outputbc || jl_options.outputunoptbc) jl_printf(JL_STDERR, "WARNING: incremental output to a .bc file is not implemented\n"); if (jl_options.outputo) jl_printf(JL_STDERR, "WARNING: incremental output to a .o file is not implemented\n"); } else { ios_t *s = NULL; if (jl_options.outputo || jl_options.outputbc || jl_options.outputunoptbc) s = jl_create_system_image(); if (jl_options.outputji) { if (s == NULL) { jl_save_system_image(jl_options.outputji); } else { ios_t f; if (ios_file(&f, jl_options.outputji, 1, 1, 1, 1) == NULL) jl_errorf("cannot open system image file \"%s\" for writing", jl_options.outputji); ios_write(&f, (const char*)s->buf, (size_t)s->size); ios_close(&f); } } if (jl_options.outputo || jl_options.outputbc || jl_options.outputunoptbc) jl_dump_native(jl_options.outputbc, jl_options.outputunoptbc, jl_options.outputo, (const char*)s->buf, (size_t)s->size); } JL_GC_POP(); }
static void show_type(jl_value_t *t) { ios_t *s = jl_current_output_stream(); if (jl_is_func_type(t)) { if (t == (jl_value_t*)jl_any_func) { ios_puts("Function", s); } else { jl_show((jl_value_t*)((jl_func_type_t*)t)->from); ios_write(s, "-->", 3); jl_show((jl_value_t*)((jl_func_type_t*)t)->to); } } else if (t == (jl_value_t*)jl_function_type) { ios_puts("Function", s); } else if (jl_is_union_type(t)) { if (t == (jl_value_t*)jl_bottom_type) { ios_write(s, "None", 4); } else if (t == jl_top_type) { ios_write(s, "Top", 3); } else { ios_write(s, "Union", 5); show_tuple(((jl_uniontype_t*)t)->types, '(', ')', 0); } } else if (jl_is_seq_type(t)) { jl_show(jl_tparam0(t)); ios_write(s, "...", 3); } else if (jl_is_typector(t)) { jl_show((jl_value_t*)((jl_typector_t*)t)->body); } else { assert(jl_is_some_tag_type(t)); jl_tag_type_t *tt = (jl_tag_type_t*)t; ios_puts(tt->name->name->name, s); jl_tuple_t *p = tt->parameters; if (p->length > 0) show_tuple(p, '{', '}', 0); } }
int main() { int major; int fd1, fd2, fd3; float value1, value2, value3; size_t i; ios_init(); major = ios_install_driver( "mon_driver.so.1.0.1", "127.0.0.1", 8080 ); printf( "Result is : %d\n", major ); if( major < 0 ) { ios_release(); return; } fd1 = ios_add_device( major, 7 ); printf( "Result is : %d\n", fd1 ); fd2 = ios_add_device( major, 3 ); printf( "Result is : %d\n", fd2 ); fd3 = ios_add_device( major, 2 ); ios_attach_global_handler( h ); ios_attach_handler( fd1, h1 ); for( i = 0; i < 60; i++ ) { sleep( 10 ); ios_read( fd1, DRV_FIELD_TEMPERATURE, &value1 ); ios_read( fd2, DRV_FIELD_TEMPERATURE, &value2 ); ios_read( fd3, DRV_FIELD_TEMPERATURE, &value3 ); printf( "Temp1 : %f / Temp2 : %f / Temp3 : %f\n", value1, value2, value3 ); ios_write( fd2, 10 ); } ios_remove_device( fd1 ); ios_remove_device( fd2 ); sleep( 1 ); ios_uninstall_driver( major ); ios_release(); return 0; }
JL_DLLEXPORT void jl_uv_puts(uv_stream_t *stream, const char *str, size_t n) { assert(stream); static_assert(offsetof(uv_stream_t,type) == offsetof(ios_t,bm) && sizeof(((uv_stream_t*)0)->type) == sizeof(((ios_t*)0)->bm), "UV and ios layout mismatch"); uv_file fd = 0; // Fallback for output during early initialisation... if (stream == (void*)STDOUT_FILENO || stream == (void*)STDERR_FILENO) { if (!jl_io_loop) jl_io_loop = uv_default_loop(); fd = (uv_file)(size_t)stream; } else if (stream->type == UV_FILE) { fd = ((jl_uv_file_t*)stream)->file; } if (fd) { // Write to file descriptor... jl_fs_write(fd, str, n, -1); } else if (stream->type > UV_HANDLE_TYPE_MAX) { // Write to ios.c stream... // This is needed because caller jl_static_show() in builtins.c can be // called from fl_print in flisp/print.c (via cvalue_printdata()), // and cvalue_printdata() passes ios_t* to jl_static_show(). ios_write((ios_t*)stream, str, n); } else { // Write to libuv stream... uv_write_t *req = (uv_write_t*)malloc(sizeof(uv_write_t)+n); char *data = (char*)(req+1); memcpy(data,str,n); uv_buf_t buf[1]; buf[0].base = data; buf[0].len = n; req->data = NULL; JL_SIGATOMIC_BEGIN(); int status = uv_write(req, stream, buf, 1, (uv_write_cb)jl_uv_writecb); JL_SIGATOMIC_END(); if (status < 0) { jl_uv_writecb(req, status); } } }
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); } }
DLLEXPORT void jl_print_array_uint8(jl_array_t *b) { ios_write(jl_current_output_stream(), (char*)b->data, b->length); }
static void jl_serialize_value_(ios_t *s, jl_value_t *v) { if (v == NULL) { write_uint8(s, Null_tag); return; } void **bp = ptrhash_bp(&ser_tag, v); if (*bp != HT_NOTFOUND) { write_as_tag(s, (uint8_t)(ptrint_t)*bp); return; } if (tree_literal_values) { // compressing tree if (!is_ast_node(v)) { writetag(s, (jl_value_t*)LiteralVal_tag); write_uint16(s, literal_val_id(v)); return; } } else { bp = ptrhash_bp(&backref_table, v); if (*bp != HT_NOTFOUND) { write_uint8(s, BackRef_tag); write_int32(s, (ptrint_t)*bp); return; } ptrhash_put(&backref_table, v, (void*)(ptrint_t)ios_pos(s)); } size_t i; if (jl_is_tuple(v)) { size_t l = ((jl_tuple_t*)v)->length; if (l <= 255) { writetag(s, jl_tuple_type); write_uint8(s, (uint8_t)l); } else { writetag(s, (jl_value_t*)LongTuple_tag); write_int32(s, l); } for(i=0; i < l; i++) { jl_serialize_value(s, jl_tupleref(v, i)); } } else if (jl_is_symbol(v)) { size_t l = strlen(((jl_sym_t*)v)->name); if (l <= 255) { writetag(s, jl_symbol_type); write_uint8(s, (uint8_t)l); } else { writetag(s, (jl_value_t*)LongSymbol_tag); write_int32(s, l); } ios_write(s, ((jl_sym_t*)v)->name, l); } else if (jl_is_array(v)) { jl_array_t *ar = (jl_array_t*)v; writetag(s, (jl_value_t*)jl_array_type); jl_serialize_value(s, ar->type); jl_value_t *elty = jl_tparam0(ar->type); for (i=0; i < ar->ndims; i++) jl_serialize_value(s, jl_box_long(jl_array_dim(ar,i))); if (jl_is_bits_type(elty)) { size_t tot = ar->length * ar->elsize; ios_write(s, ar->data, tot); } else { for(i=0; i < ar->length; i++) { jl_serialize_value(s, jl_cellref(v, i)); } } } else if (jl_is_expr(v)) { jl_expr_t *e = (jl_expr_t*)v; size_t l = e->args->length; if (l <= 255) { writetag(s, jl_expr_type); write_uint8(s, (uint8_t)l); } else { writetag(s, (jl_value_t*)LongExpr_tag); write_int32(s, l); } jl_serialize_value(s, e->head); jl_serialize_value(s, e->etype); for(i=0; i < l; i++) { jl_serialize_value(s, jl_exprarg(e, i)); } } else if (jl_is_some_tag_type(v)) { jl_serialize_tag_type(s, v); } else if (jl_is_typevar(v)) { writetag(s, jl_tvar_type); jl_serialize_value(s, ((jl_tvar_t*)v)->name); jl_serialize_value(s, ((jl_tvar_t*)v)->lb); jl_serialize_value(s, ((jl_tvar_t*)v)->ub); write_int8(s, ((jl_tvar_t*)v)->bound); } else if (jl_is_function(v)) { writetag(s, jl_func_kind); jl_serialize_value(s, v->type); jl_function_t *f = (jl_function_t*)v; jl_serialize_value(s, (jl_value_t*)f->linfo); jl_serialize_value(s, f->env); if (f->linfo && f->linfo->ast && (jl_is_expr(f->linfo->ast) || jl_is_tuple(f->linfo->ast)) && f->fptr != &jl_trampoline) { write_int32(s, 0); } else { jl_serialize_fptr(s, f->fptr); } } else if (jl_is_lambda_info(v)) { writetag(s, jl_lambda_info_type); jl_lambda_info_t *li = (jl_lambda_info_t*)v; jl_serialize_value(s, li->ast); jl_serialize_value(s, (jl_value_t*)li->sparams); // don't save cached type info for code in the Base module, because // it might reference types in the old System module. if (li->module == jl_base_module) jl_serialize_value(s, (jl_value_t*)jl_null); else jl_serialize_value(s, (jl_value_t*)li->tfunc); jl_serialize_value(s, (jl_value_t*)li->name); jl_serialize_value(s, (jl_value_t*)li->specTypes); jl_serialize_value(s, (jl_value_t*)li->specializations); jl_serialize_value(s, (jl_value_t*)li->inferred); jl_serialize_value(s, (jl_value_t*)li->file); jl_serialize_value(s, (jl_value_t*)li->line); jl_serialize_value(s, (jl_value_t*)li->module); } else if (jl_typeis(v, jl_module_type)) { jl_serialize_module(s, (jl_module_t*)v); } else if (jl_typeis(v, jl_methtable_type)) { writetag(s, jl_methtable_type); jl_methtable_t *mt = (jl_methtable_t*)v; jl_serialize_methlist(s, mt->defs); jl_serialize_methlist(s, mt->cache); jl_serialize_value(s, mt->cache_1arg); write_int32(s, mt->max_args); } else if (jl_typeis(v, jl_task_type)) { jl_error("Task cannot be serialized"); } else { jl_value_t *t = (jl_value_t*)jl_typeof(v); if (jl_is_bits_type(t)) { void *data = jl_bits_data(v); if (t == (jl_value_t*)jl_int64_type && *(int64_t*)data >= S32_MIN && *(int64_t*)data <= S32_MAX) { writetag(s, (jl_value_t*)SmallInt64_tag); write_int32(s, (int32_t)*(int64_t*)data); } else { int nb = ((jl_bits_type_t*)t)->nbits; writetag(s, jl_bits_kind); jl_serialize_value(s, t); ios_write(s, data, nb/8); } } else if (jl_is_struct_type(t)) { writetag(s, jl_struct_kind); jl_serialize_value(s, t); size_t nf = ((jl_struct_type_t*)t)->names->length; size_t i; for(i=0; i < nf; i++) { jl_value_t *fld = ((jl_value_t**)v)[i+1]; jl_serialize_value(s, fld); } if (t == jl_idtable_type) { jl_cell_1d_push(idtable_list, v); } } else { assert(0); } } }
static void outsn(char *s, ios_t *f, size_t n) { ios_write(f, s, n); HPOS += u8_strwidth(s); }
void jl_write_compiler_output(void) { if (!jl_generating_output()) { if (jl_options.outputjitbc) jl_dump_native(NULL, jl_options.outputjitbc, NULL, NULL, 0); return; } if (!jl_options.incremental) jl_precompile(jl_options.compile_enabled == JL_OPTIONS_COMPILE_ALL); if (!jl_module_init_order) { jl_printf(JL_STDERR, "WARNING: --output requested, but no modules defined during run\n"); return; } if (jl_options.outputjitbc) { jl_printf(JL_STDERR, "WARNING: --output-jit-bc is meaningless with options for dumping sysimage data\n"); } jl_array_t *worklist = jl_module_init_order; JL_GC_PUSH1(&worklist); jl_module_init_order = jl_alloc_vec_any(0); int i, l = jl_array_len(worklist); for (i = 0; i < l; i++) { jl_value_t *m = jl_ptrarrayref(worklist, i); jl_value_t *f = jl_get_global((jl_module_t*)m, jl_symbol("__init__")); if (f) { jl_array_ptr_1d_push(jl_module_init_order, m); // TODO: this would be better handled if moved entirely to jl_precompile // since it's a slightly duplication of effort jl_value_t *tt = jl_is_type(f) ? (jl_value_t*)jl_wrap_Type(f) : jl_typeof(f); JL_GC_PUSH1(&tt); tt = (jl_value_t*)jl_apply_tuple_type_v(&tt, 1); jl_compile_hint((jl_tupletype_t*)tt); JL_GC_POP(); } } if (jl_options.incremental) { if (jl_options.outputji) if (jl_save_incremental(jl_options.outputji, worklist)) jl_exit(1); if (jl_options.outputbc || jl_options.outputunoptbc) jl_printf(JL_STDERR, "WARNING: incremental output to a .bc file is not implemented\n"); if (jl_options.outputo) jl_printf(JL_STDERR, "WARNING: incremental output to a .o file is not implemented\n"); } else { ios_t *s = NULL; if (jl_options.outputo || jl_options.outputbc || jl_options.outputunoptbc) s = jl_create_system_image(); if (jl_options.outputji) { if (s == NULL) { jl_save_system_image(jl_options.outputji); } else { ios_t f; if (ios_file(&f, jl_options.outputji, 1, 1, 1, 1) == NULL) jl_errorf("cannot open system image file \"%s\" for writing", jl_options.outputji); ios_write(&f, (const char*)s->buf, (size_t)s->size); ios_close(&f); } } if (jl_options.outputo || jl_options.outputbc || jl_options.outputunoptbc) { assert(s); jl_dump_native(jl_options.outputbc, jl_options.outputunoptbc, jl_options.outputo, (const char*)s->buf, (size_t)s->size); } } for (size_t i = 0; i < jl_current_modules.size; i += 2) { if (jl_current_modules.table[i + 1] != HT_NOTFOUND) { jl_printf(JL_STDERR, "\nWARNING: detected unclosed module: "); jl_static_show(JL_STDERR, (jl_value_t*)jl_current_modules.table[i]); jl_printf(JL_STDERR, "\n ** incremental compilation may be broken for this module **\n\n"); } } JL_GC_POP(); }
static void outsn(fl_context_t *fl_ctx, char *s, ios_t *f, size_t n) { ios_write(f, s, n); fl_ctx->HPOS += u8_strwidth(s); }