/* Finish building a FunctionType 2 (ExponentialInterpolation) function. */ int gs_build_function_2(i_ctx_t *i_ctx_p, const ref *op, const gs_function_params_t * mnDR, int depth, gs_function_t ** ppfn, gs_memory_t *mem) { gs_function_ElIn_params_t params; int code, n0, n1; *(gs_function_params_t *)¶ms = *mnDR; params.C0 = 0; params.C1 = 0; if ((code = dict_float_param(op, "N", 0.0, ¶ms.N)) != 0 || (code = n0 = fn_build_float_array_forced(op, "C0", false, ¶ms.C0, mem)) < 0 || (code = n1 = fn_build_float_array_forced(op, "C1", false, ¶ms.C1, mem)) < 0 ) goto fail; if (params.C0 == 0) n0 = 1; /* C0 defaulted */ if (params.C1 == 0) n1 = 1; /* C1 defaulted */ if (params.Range == 0) params.n = n0; /* either one will do */ if (n0 != n1 || n0 != params.n) goto fail; code = gs_function_ElIn_init(ppfn, ¶ms, mem); if (code >= 0) return 0; fail: gs_function_ElIn_free_params(¶ms, mem); return (code < 0 ? code : gs_note_error(e_rangecheck)); }
/* The caller guarantees that *op is a dictionary. */ int build_gs_outline_font(i_ctx_t *i_ctx_p, os_ptr op, gs_font_base ** ppfont, font_type ftype, gs_memory_type_ptr_t pstype, const build_proc_refs * pbuild, build_font_options_t options, build_base_font_proc_t build_base_font) { int painttype; float strokewidth; gs_font_base *pfont; int code = dict_int_param(op, "PaintType", 0, 3, 0, &painttype); if (code < 0) return code; code = dict_float_param(op, "StrokeWidth", 0.0, &strokewidth); if (code < 0) return code; code = build_base_font(i_ctx_p, op, ppfont, ftype, pstype, pbuild, options); if (code != 0) return code; pfont = *ppfont; pfont->PaintType = painttype; pfont->StrokeWidth = strokewidth; return 0; }
/* * Get the additional parameters for a Type 2 font (or FontType 2 FDArray * entry in a CIDFontType 0 font), beyond those common to Type 1 and Type 2 * fonts. */ int type2_font_params(const_os_ptr op, charstring_font_refs_t *pfr, gs_type1_data *pdata1) { int code; float dwx, nwx; ref *temp; pdata1->interpret = gs_type2_interpret; pdata1->lenIV = DEFAULT_LENIV_2; pdata1->subroutineNumberBias = subr_bias(pfr->Subrs); /* Get information specific to Type 2 fonts. */ if (dict_find_string(pfr->Private, "GlobalSubrs", &temp) > 0) { if (!r_is_array(temp)) return_error(e_typecheck); pfr->GlobalSubrs = temp; } pdata1->gsubrNumberBias = subr_bias(pfr->GlobalSubrs); if ((code = dict_uint_param(pfr->Private, "gsubrNumberBias", 0, max_uint, pdata1->gsubrNumberBias, &pdata1->gsubrNumberBias)) < 0 || (code = dict_float_param(pfr->Private, "defaultWidthX", 0.0, &dwx)) < 0 || (code = dict_float_param(pfr->Private, "nominalWidthX", 0.0, &nwx)) < 0 ) return code; pdata1->defaultWidthX = float2fixed(dwx); pdata1->nominalWidthX = float2fixed(nwx); { ref *pirs; if (dict_find_string(pfr->Private, "initialRandomSeed", &pirs) <= 0) pdata1->initialRandomSeed = 0; else if (!r_has_type(pirs, t_integer)) return_error(e_typecheck); else pdata1->initialRandomSeed = pirs->value.intval; } return 0; }
/* from a dictionary. */ static int dict_spot_params(const ref * pdict, gs_spot_halftone * psp, ref * psproc, ref * ptproc) { int code; check_dict_read(*pdict); if ((code = dict_float_param(pdict, "Frequency", 0.0, &psp->screen.frequency)) != 0 || (code = dict_float_param(pdict, "Angle", 0.0, &psp->screen.angle)) != 0 || (code = dict_proc_param(pdict, "SpotFunction", psproc, false)) != 0 || (code = dict_bool_param(pdict, "AccurateScreens", gs_currentaccuratescreens(), &psp->accurate_screens)) < 0 || (code = dict_proc_param(pdict, "TransferFunction", ptproc, false)) < 0 ) return (code < 0 ? code : e_undefined); psp->transfer = (code > 0 ? (gs_mapping_proc) 0 : gs_mapped_transfer); psp->transfer_closure.proc = 0; psp->transfer_closure.data = 0; return 0; }
/* * Similar to fn_build_float_array() except * - numeric parameter is accepted and converted to 1-element array * - number of elements is not checked for even/odd */ int fn_build_float_array_forced(const ref * op, const char *kstr, bool required, const float **pparray, gs_memory_t *mem) { ref *par; int code; uint size; float *ptr; *pparray = 0; if (dict_find_string(op, kstr, &par) <= 0) return (required ? gs_note_error(gs_error_rangecheck) : 0); if( r_is_array(par) ) size = r_size(par); else if(r_type(par) == t_integer || r_type(par) == t_real) size = 1; else return_error(gs_error_typecheck); ptr = (float *)gs_alloc_byte_array(mem, size, sizeof(float), kstr); if (ptr == 0) return_error(gs_error_VMerror); if(r_is_array(par) ) code = dict_float_array_check_param(mem, op, kstr, size, ptr, NULL, 0, gs_error_rangecheck); else { code = dict_float_param(op, kstr, 0., ptr); /* defailt cannot happen */ if( code == 0 ) code = 1; } if (code < 0 ) { gs_free_object(mem, ptr, kstr); return code; } *pparray = ptr; return code; }