/* Create a dictionary using the given allocator. */ int dict_alloc(gs_ref_memory_t * mem, uint size, ref * pdref) { ref arr; int code = gs_alloc_ref_array(mem, &arr, a_all, sizeof(dict) / sizeof(ref), "dict_alloc"); dict *pdict; ref dref; if (code < 0) return code; pdict = (dict *) arr.value.refs; make_tav(&dref, t_dictionary, r_space(&arr) | imemory_new_mask(mem) | a_all, pdict, pdict); make_struct(&pdict->memory, avm_foreign, mem); code = dict_create_contents(size, &dref, dict_default_pack); if (code < 0) { gs_free_ref_array(mem, &arr, "dict_alloc"); return code; } *pdref = dref; return 0; }
/* Allocate, and prepare to load, the index or tint map. */ int zcs_begin_map(i_ctx_t *i_ctx_p, gs_indexed_map ** pmap, const ref * pproc, int num_entries, const gs_color_space * base_space, op_proc_t map1) { gs_memory_t *mem = gs_state_memory(igs); int space = imemory_space((gs_ref_memory_t *)mem); int num_components = cs_num_components(base_space); int num_values = num_entries * num_components; gs_indexed_map *map; int code = alloc_indexed_map(&map, num_values, mem, "setcolorspace(mapped)"); es_ptr ep; if (code < 0) return code; *pmap = map; /* Map the entire set of color indices. Since the */ /* o-stack may not be able to hold N*4096 values, we have */ /* to load them into the cache as they are generated. */ check_estack(num_csme + 1); /* 1 extra for map1 proc */ ep = esp += num_csme; make_int(ep + csme_num_components, num_components); make_struct(ep + csme_map, space, map); ep[csme_proc] = *pproc; make_int(ep + csme_hival, num_entries - 1); make_int(ep + csme_index, -1); push_op_estack(map1); return o_push_estack; }
/* the code for Type 1 halftones in sethalftone. */ int zscreen_enum_init(i_ctx_t *i_ctx_p, const gx_ht_order * porder, gs_screen_halftone * psp, ref * pproc, int npop, int (*finish_proc)(i_ctx_t *), int space_index) { gs_screen_enum *penum; gs_memory_t * mem = (gs_memory_t *)idmemory->spaces_indexed[space_index]; int code; check_estack(snumpush + 1); penum = gs_screen_enum_alloc(mem, "setscreen"); if (penum == 0) return_error(e_VMerror); make_struct(esp + snumpush, space_index << r_space_shift, penum); /* do early for screen_cleanup in case of error */ code = gs_screen_enum_init_memory(penum, porder, igs, psp, mem); if (code < 0) { screen_cleanup(i_ctx_p); return code; } /* Push everything on the estack */ make_mark_estack(esp + 1, es_other, screen_cleanup); esp += snumpush; make_op_estack(esp - 2, finish_proc); sproc = *pproc; push_op_estack(screen_sample); pop(npop); return o_push_estack; }
/* <bool> setpacking - */ static int zsetpacking(i_ctx_t *i_ctx_p) { os_ptr op = osp; ref cont; check_type(*op, t_boolean); make_struct(&cont, avm_local, ref_array_packing_container); ref_assign_old(&cont, &ref_array_packing, op, "setpacking"); pop(1); return 0; }
/* * call-seq: * Struct.new( [aString] [, aSym]+> ) -> StructClass * StructClass.new(arg, ...) -> obj * StructClass[arg, ...] -> obj * * Creates a new class, named by <i>aString</i>, containing accessor * methods for the given symbols. If the name <i>aString</i> is * omitted, an anonymous structure class will be created. Otherwise, * the name of this struct will appear as a constant in class * <code>Struct</code>, so it must be unique for all * <code>Struct</code>s in the system and should start with a capital * letter. Assigning a structure class to a constant effectively gives * the class the name of the constant. * * <code>Struct::new</code> returns a new <code>Class</code> object, * which can then be used to create specific instances of the new * structure. The number of actual parameters must be * less than or equal to the number of attributes defined for this * class; unset parameters default to <code>nil</code>. Passing too many * parameters will raise an <code>ArgumentError</code>. * * The remaining methods listed in this section (class and instance) * are defined for this generated class. * * # Create a structure with a name in Struct * Struct.new("Customer", :name, :address) #=> Struct::Customer * Struct::Customer.new("Dave", "123 Main") #=> #<struct Struct::Customer name="Dave", address="123 Main"> * * # Create a structure named by its constant * Customer = Struct.new(:name, :address) #=> Customer * Customer.new("Dave", "123 Main") #=> #<struct Customer name="Dave", address="123 Main"> */ static mrb_value mrb_struct_s_def(mrb_state *mrb, mrb_value klass) { mrb_value name, rest; mrb_value *pargv; int argcnt; mrb_int i; mrb_value b, st; mrb_sym id; mrb_value *argv; int argc; name = mrb_nil_value(); rest = mrb_nil_value(); mrb_get_args(mrb, "*&", &argv, &argc, &b); if (argc == 0) { /* special case to avoid crash */ rest = mrb_ary_new(mrb); } else { if (argc > 0) name = argv[0]; if (argc > 1) rest = argv[1]; if (mrb_array_p(rest)) { if (!mrb_nil_p(name) && mrb_symbol_p(name)) { /* 1stArgument:symbol -> name=nil rest=argv[0]-[n] */ mrb_ary_unshift(mrb, rest, name); name = mrb_nil_value(); } } else { pargv = &argv[1]; argcnt = argc-1; if (!mrb_nil_p(name) && mrb_symbol_p(name)) { /* 1stArgument:symbol -> name=nil rest=argv[0]-[n] */ name = mrb_nil_value(); pargv = &argv[0]; argcnt++; } rest = mrb_ary_new_from_values(mrb, argcnt, pargv); } for (i=0; i<RARRAY_LEN(rest); i++) { id = mrb_obj_to_sym(mrb, RARRAY_PTR(rest)[i]); RARRAY_PTR(rest)[i] = mrb_symbol_value(id); } } st = make_struct(mrb, name, rest, struct_class(mrb)); if (!mrb_nil_p(b)) { mrb_yield_with_class(mrb, b, 1, &st, st, mrb_class_ptr(klass)); } return st; }
/* <int> setobjectformat - */ static int zsetobjectformat(i_ctx_t *i_ctx_p) { os_ptr op = osp; ref cont; check_type(*op, t_integer); if (op->value.intval < 0 || op->value.intval > 4) return_error(gs_error_rangecheck); make_struct(&cont, avm_local, ref_binary_object_format_container); ref_assign_old(&cont, &ref_binary_object_format, op, "setobjectformat"); pop(1); return 0; }
/* * call-seq: * Struct.new( [aString] [, aSym]+> ) -> StructClass * StructClass.new(arg, ...) -> obj * StructClass[arg, ...] -> obj * * Creates a new class, named by <i>aString</i>, containing accessor * methods for the given symbols. If the name <i>aString</i> is * omitted, an anonymous structure class will be created. Otherwise, * the name of this struct will appear as a constant in class * <code>Struct</code>, so it must be unique for all * <code>Struct</code>s in the system and should start with a capital * letter. Assigning a structure class to a constant effectively gives * the class the name of the constant. * * <code>Struct::new</code> returns a new <code>Class</code> object, * which can then be used to create specific instances of the new * structure. The number of actual parameters must be * less than or equal to the number of attributes defined for this * class; unset parameters default to <code>nil</code>. Passing too many * parameters will raise an <code>ArgumentError</code>. * * The remaining methods listed in this section (class and instance) * are defined for this generated class. * * # Create a structure with a name in Struct * Struct.new("Customer", :name, :address) #=> Struct::Customer * Struct::Customer.new("Dave", "123 Main") #=> #<struct Struct::Customer name="Dave", address="123 Main"> * * # Create a structure named by its constant * Customer = Struct.new(:name, :address) #=> Customer * Customer.new("Dave", "123 Main") #=> #<struct Customer name="Dave", address="123 Main"> */ static mrb_value mrb_struct_s_def(mrb_state *mrb, mrb_value klass) { mrb_value name, rest; mrb_value *pargv; int argcnt; long i; mrb_value b, st; mrb_sym id; mrb_value *argv; int argc; name = mrb_nil_value(); rest = mrb_nil_value(); mrb_get_args(mrb, "&*", &b, &argv, &argc); if (argc > 0) name = argv[0]; if (argc > 1) rest = argv[1]; //mrb_scan_args(argc, argv, "1*", &name, &rest); if (mrb_type(rest) == MRB_TT_ARRAY) { if (!mrb_nil_p(name) && SYMBOL_P(name)) { /* 1stArgument:symbol -> name=nil rest=argv[0]-[n] */ mrb_ary_unshift(mrb, rest, name); name = mrb_nil_value(); } for (i=0; i<RARRAY_LEN(rest); i++) { id = mrb_to_id(mrb, RARRAY_PTR(rest)[i]); RARRAY_PTR(rest)[i] = mrb_str_new_cstr(mrb, mrb_sym2name(mrb, id)); } } else { pargv = &argv[1]; argcnt = argc-1; if (!mrb_nil_p(name) && SYMBOL_P(name)) { /* 1stArgument:symbol -> name=nil rest=argv[0]-[n] */ //mrb_ary_unshift(mrb, rest, name); name = mrb_nil_value(); pargv = &argv[0]; argcnt++; } rest = mrb_ary_new_from_values(mrb, pargv, argcnt); } st = make_struct(mrb, name, rest, struct_class(mrb)); if (!mrb_nil_p(b)) { mrb_funcall(mrb, b, "call", 1, &st); } return st; }
mrb_value mrb_struct_define(mrb_state *mrb, const char *name, ...) { va_list ar; mrb_value nm, ary; char *mem; if (!name) nm = mrb_nil_value(); else nm = mrb_str_new_cstr(mrb, name); ary = mrb_ary_new(mrb); va_start(ar, name); while ((mem = va_arg(ar, char*)) != 0) { mrb_sym slot = mrb_intern_cstr(mrb, mem); mrb_ary_push(mrb, ary, mrb_symbol_value(slot)); } va_end(ar); return make_struct(mrb, nm, ary, struct_class(mrb)); }
VALUE rb_struct_define(const char *name, ...) { va_list ar; VALUE nm, ary; char *mem; if (!name) nm = Qnil; else nm = rb_str_new2(name); ary = rb_ary_new(); va_start(ar, name); while ((mem = va_arg(ar, char*)) != 0) { ID slot = rb_intern(mem); rb_ary_push(ary, ID2SYM(slot)); } va_end(ar); return make_struct(nm, ary, rb_cStruct); }
/* Initialize the graphics stack. */ gs_state * int_gstate_alloc(const gs_dual_memory_t * dmem) { int_gstate *iigs; ref proc0; int_remap_color_info_t *prci; gs_ref_memory_t *lmem = dmem->space_local; gs_ref_memory_t *gmem = dmem->space_global; gs_state *pgs = gs_state_alloc((gs_memory_t *)lmem); iigs = gs_alloc_struct((gs_memory_t *)lmem, int_gstate, &st_int_gstate, "int_gstate_alloc(int_gstate)"); int_gstate_map_refs(iigs, make_null); make_empty_array(&iigs->dash_pattern_array, a_all); gs_alloc_ref_array(lmem, &proc0, a_readonly + a_executable, 2, "int_gstate_alloc(proc0)"); make_oper(proc0.value.refs, 0, zpop); make_real(proc0.value.refs + 1, 0.0); iigs->black_generation = proc0; iigs->undercolor_removal = proc0; make_false(&iigs->use_cie_color); /* * Even though the gstate itself is allocated in local VM, the * container for the color remapping procedure must be allocated in * global VM so that the gstate can be copied into global VM. */ prci = gs_alloc_struct((gs_memory_t *)gmem, int_remap_color_info_t, &st_int_remap_color_info, "int_gstate_alloc(remap color info)"); make_struct(&iigs->remap_color_info, imemory_space(gmem), prci); clear_pagedevice(iigs); gs_state_set_client(pgs, iigs, &istate_procs, true); /* PostScript code wants limit clamping enabled. */ gs_setlimitclamp(pgs, true); /* * gsave and grestore only work properly * if there are always at least 2 entries on the stack. * We count on the PostScript initialization code to do a gsave. */ return pgs; }
/* entry point to merge sort. Do not change the interface */ int run_msort(char *params, index_value **_array) { char *arr[5]; ms_args sort_struct; char* filename = NULL; int k; parse_file(params, arr); filename = arr[1]; index_value *array = malloc(sizeof (index_value) * (atoi(arr[2]))); sort_struct.start = 0; sort_struct.array = make_struct(filename, array); sort_struct.end = atoi(arr[2])-1; sort_struct.bubble_threshold = atoi(arr[4]); sort_struct.less = &comp_coords; sort_struct.parallel_depth = atoi(arr[3])-1; merge_sort(sort_struct.array, sort_struct.start, sort_struct.end,sort_struct.less,sort_struct.bubble_threshold); FILE *fp = fopen(arr[0], "w"); if (fp == NULL) return 0; for(k=0; k < sort_struct.end+1; k++) { fprintf(fp,"%d,%d,%f\n", sort_struct.array[k].i, sort_struct.array[k].j, sort_struct.array[k].value); } fclose(fp); free(array); return 0; }
static bool make_tuple(compile_t* c, ast_t* ast, gentype_t* g) { // An anonymous structure with no functions and no vtable. if(setup_name(c, ast, g, false)) return true; setup_tuple_fields(g); dwarf_forward(&c->dwarf, g); bool ok = make_struct(c, g) && make_components(c, g); // Finalise debug symbols for tuple type. dwarf_composite(&c->dwarf, g); dwarf_finish(&c->dwarf); // Generate a descriptor. gendesc_init(c, g); free_fields(g); return ok; }
static VALUE rb_struct_s_def(int argc, VALUE *argv, VALUE klass) { VALUE name, rest; long i; VALUE st; ID id; rb_scan_args(argc, argv, "1*", &name, &rest); if (!NIL_P(name) && SYMBOL_P(name)) { rb_ary_unshift(rest, name); name = Qnil; } for (i=0; i<RARRAY_LEN(rest); i++) { id = rb_to_id(RARRAY_PTR(rest)[i]); RARRAY_PTR(rest)[i] = ID2SYM(id); } st = make_struct(name, rest, klass); if (rb_block_given_p()) { rb_mod_module_eval(0, 0, st); } return st; }
static VALUE rb_struct_s_def(VALUE klass, SEL sel, int argc, VALUE *argv) { VALUE name, rest; long i, count; VALUE st; ID id; rb_scan_args(argc, argv, "1*", &name, &rest); if (!NIL_P(name) && SYMBOL_P(name)) { rb_ary_unshift(rest, name); name = Qnil; } for (i = 0, count = RARRAY_LEN(rest); i < count; i++) { id = rb_to_id(RARRAY_AT(rest, i)); rb_ary_store(rest, i, ID2SYM(id)); } st = make_struct(name, rest, klass); if (rb_block_given_p()) { rb_mod_module_eval(st, 0, 0, 0); } return st; }
static bool make_nominal(compile_t* c, ast_t* ast, gentype_t* g, bool prelim) { assert(ast_id(ast) == TK_NOMINAL); ast_t* def = (ast_t*)ast_data(ast); token_id id = ast_id(def); // For traits, just return a raw object pointer. switch(id) { case TK_INTERFACE: case TK_TRAIT: g->underlying = id; g->use_type = c->object_ptr; dwarf_trait(&c->dwarf, g); return true; default: {} } // If we already exist or we're preliminary, we're done. if(setup_name(c, ast, g, prelim)) return true; if(g->primitive == NULL) { // Not a primitive type. Generate all the fields and a trace function. setup_type_fields(g); // Forward declare debug symbols for this nominal, if needed. // At this point, this can only be TK_STRUCT, TK_CLASS, TK_PRIMITIVE, or // TK_ACTOR ast nodes. TK_TYPE has been translated to any of the former // during reification. dwarf_forward(&c->dwarf, g); bool ok = make_struct(c, g); if(!g->done) ok = ok && make_trace(c, g) && make_components(c, g); if(!ok) { free_fields(g); return false; } // Finalise symbols for composite type. if(!g->done) dwarf_composite(&c->dwarf, g); } else { // Emit debug symbols for a basic type (U8, U16, U32...) dwarf_basic(&c->dwarf, g); // Create a box type. make_box_type(c, g); } if(!g->done) { // Generate a dispatch function if necessary. make_dispatch(c, g); // Create a unique global instance if we need one. make_global_instance(c, g); // Generate all the methods. if(!genfun_methods(c, g)) { free_fields(g); return false; } if(g->underlying != TK_STRUCT) gendesc_init(c, g); // Finish off the dispatch function. if(g->underlying == TK_ACTOR) { codegen_startfun(c, g->dispatch_fn, false); codegen_finishfun(c); } // Finish the dwarf frame. dwarf_finish(&c->dwarf); } free_fields(g); g->done = true; return true; }
static int zimage_data_setup(i_ctx_t *i_ctx_p, const gs_pixel_image_t * pim, gx_image_enum_common_t * pie, const ref * sources, int npop) { int num_sources = pie->num_planes; int inumpush = NUM_PUSH(num_sources); int code; gs_image_enum *penum; int px; const ref *pp; bool string_sources = true; check_estack(inumpush + 2); /* stuff above, + continuation + proc */ make_int(EBOT_NUM_SOURCES(esp), num_sources); /* * Note that the data sources may be procedures, strings, or (Level * 2 only) files. (The Level 1 reference manual says that Level 1 * requires procedures, but Adobe Level 1 interpreters also accept * strings.) The sources must all be of the same type. * * The Adobe documentation explicitly says that if two or more of the * data sources are the same or inter-dependent files, the result is not * defined. We don't have a problem with the bookkeeping for * inter-dependent files, since each one has its own buffer, but we do * have to be careful if two or more sources are actually the same file. * That is the reason for the aliasing information described above. */ for (px = 0, pp = sources; px < num_sources; px++, pp++) { es_ptr ep = EBOT_SOURCE(esp, px); make_int(ep + 1, 1); /* default is no aliasing */ switch (r_type(pp)) { case t_file: if (!level2_enabled) return_error(e_typecheck); /* Check for aliasing. */ { int pi; for (pi = 0; pi < px; ++pi) if (sources[pi].value.pfile == pp->value.pfile) { /* Record aliasing */ make_int(ep + 1, -pi); EBOT_SOURCE(esp, pi)[1].value.intval++; break; } } string_sources = false; /* falls through */ case t_string: if (r_type(pp) != r_type(sources)) { if (pie != NULL) gx_image_end(pie, false); /* Clean up pie */ return_error(e_typecheck); } check_read(*pp); break; default: if (!r_is_proc(sources)) { static const char ds[] = "DataSource"; if (pie != NULL) gx_image_end(pie, false); /* Clean up pie */ gs_errorinfo_put_pair(i_ctx_p, ds, sizeof(ds) - 1, pp); return_error(e_typecheck); } check_proc(*pp); string_sources = false; } *ep = *pp; } /* Always place the image enumerator into local memory, because pie may have local objects inherited from igs, which may be local when the current allocation mode is global. Bug 688140. */ if ((penum = gs_image_enum_alloc(imemory_local, "image_setup")) == 0) return_error(e_VMerror); code = gs_image_enum_init(penum, pie, (const gs_data_image_t *)pim, igs); if (code != 0 || (pie->skipping && string_sources)) { /* error, or empty image */ int code1 = gs_image_cleanup_and_free_enum(penum, igs); if (code >= 0) /* empty image */ pop(npop); if (code >= 0 && code1 < 0) code = code1; return code; } push_mark_estack(es_other, image_cleanup); esp += inumpush - 1; make_int(ETOP_PLANE_INDEX(esp), 0); make_int(ETOP_NUM_SOURCES(esp), num_sources); make_struct(esp, avm_local, penum); switch (r_type(sources)) { case t_file: push_op_estack(image_file_continue); break; case t_string: push_op_estack(image_string_continue); break; default: /* procedure */ push_op_estack(image_proc_process); break; } pop(npop); return o_push_estack; }
bool gentypes(compile_t* c) { reachable_type_t* t; size_t i; genprim_builtins(c); PONY_LOG(c->opt, VERBOSITY_INFO, (" Data prototypes\n")); i = HASHMAP_BEGIN; while((t = reachable_types_next(&c->reachable->types, &i)) != NULL) { if(!make_opaque_struct(c, t)) return false; gendesc_type(c, t); make_debug_info(c, t); make_box_type(c, t); make_dispatch(c, t); gentrace_prototype(c, t); } PONY_LOG(c->opt, VERBOSITY_INFO, (" Data types\n")); i = HASHMAP_BEGIN; while((t = reachable_types_next(&c->reachable->types, &i)) != NULL) { if(!make_struct(c, t)) return false; make_global_instance(c, t); } PONY_LOG(c->opt, VERBOSITY_INFO, (" Function prototypes\n")); i = HASHMAP_BEGIN; while((t = reachable_types_next(&c->reachable->types, &i)) != NULL) { make_debug_final(c, t); make_pointer_methods(c, t); if(!genfun_method_sigs(c, t)) return false; } PONY_LOG(c->opt, VERBOSITY_INFO, (" Functions\n")); i = HASHMAP_BEGIN; while((t = reachable_types_next(&c->reachable->types, &i)) != NULL) { if(!genfun_method_bodies(c, t)) return false; } PONY_LOG(c->opt, VERBOSITY_INFO, (" Descriptors\n")); i = HASHMAP_BEGIN; while((t = reachable_types_next(&c->reachable->types, &i)) != NULL) { if(!make_trace(c, t)) return false; gendesc_init(c, t); } return true; }
bool gentypes(compile_t* c) { reach_type_t* t; size_t i; genprim_builtins(c); if(c->opt->verbosity >= VERBOSITY_INFO) fprintf(stderr, " Data prototypes\n"); i = HASHMAP_BEGIN; while((t = reach_types_next(&c->reach->types, &i)) != NULL) { if(!make_opaque_struct(c, t)) return false; gendesc_type(c, t); make_debug_info(c, t); make_box_type(c, t); make_dispatch(c, t); gentrace_prototype(c, t); } gendesc_table(c); if(c->opt->verbosity >= VERBOSITY_INFO) fprintf(stderr, " Data types\n"); i = HASHMAP_BEGIN; while((t = reach_types_next(&c->reach->types, &i)) != NULL) { if(!make_struct(c, t)) return false; make_global_instance(c, t); } if(c->opt->verbosity >= VERBOSITY_INFO) fprintf(stderr, " Function prototypes\n"); i = HASHMAP_BEGIN; while((t = reach_types_next(&c->reach->types, &i)) != NULL) { // The ABI size for machine words and tuples is the boxed size. if(t->structure != NULL) t->abi_size = (size_t)LLVMABISizeOfType(c->target_data, t->structure); make_debug_final(c, t); make_pointer_methods(c, t); if(!genfun_method_sigs(c, t)) return false; } if(c->opt->verbosity >= VERBOSITY_INFO) fprintf(stderr, " Functions\n"); i = HASHMAP_BEGIN; while((t = reach_types_next(&c->reach->types, &i)) != NULL) { if(!genfun_method_bodies(c, t)) return false; } if(c->opt->verbosity >= VERBOSITY_INFO) fprintf(stderr, " Descriptors\n"); i = HASHMAP_BEGIN; while((t = reach_types_next(&c->reach->types, &i)) != NULL) { if(!make_trace(c, t)) return false; if(!genserialise(c, t)) return false; gendesc_init(c, t); } return true; }