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

/* If the font name isn't a name or a string, return an empty string. */voidget_font_name(const gs_memory_t *mem, ref * pfname, const ref * op){    switch (r_type(op)) {        case t_string:            *pfname = *op;            break;        case t_name:            name_string_ref(mem, op, pfname);            break;        default:            /* This is weird, but legal.... */            make_empty_string(pfname, a_readonly);    }}

static gs_chargs_font_map_glyph_by_dict(const gs_memory_t *mem, const ref *map, gs_glyph glyph){    ref *v, n;    if (glyph >= gs_min_cid_glyph) {        uint cid = glyph - gs_min_cid_glyph;        if (dict_find_string(map, "CIDCount", &v) > 0) {            /* This is a CIDDEcoding resource. */            make_int(&n, cid / 256);            if (dict_find(map, &n, &v) > 0) {                ref vv;                if (array_get(mem, v, cid % 256, &vv) == 0 && r_type(&vv) == t_integer)                    return vv.value.intval;            }            return GS_NO_CHAR; /* Absent in the map. */        }        /* This is GlyphNames2Unicode dictionary. */        make_int(&n, cid);    } else        name_index_ref(mem, glyph, &n);     if (dict_find(map, &n, &v) > 0) {        if (r_has_type(v, t_string)) {            int i, l = r_size(v);            gs_char c = 0;            for (i = 0; i < l; i++)                c = (c << 8) | v->value.const_bytes[i];            return c;        }        if (r_type(v) == t_integer)            return v->value.intval;    }    return GS_NO_CHAR; /* Absent in the map. */}

void test_sra(){	printf("===test SRA===/n");	struct cpu_struct cpu;	memset(&cpu, 0, sizeof(cpu));	cpu.current_ins.rt = 1;	cpu.current_ins.rd = 2;	cpu.current_ins.shamt = 3;	cpu.current_ins.funct = 0x03;	cpu.reg[1] = 0x80000000;	r_type(&cpu);	printf("%s/n", word_to_binary(cpu.reg[1], 0, 31));	printf("%s/n", word_to_binary(cpu.reg[2], 0, 31));	assert(cpu.reg[2] == 0xf0000000);	printf("pass/n/n");}

/* If an error is returned, the return value is not updated. */intreal_param(const ref * op, double *pparam){    switch (r_type(op)) {	case t_integer:	    *pparam = op->value.intval;	    break;	case t_real:	    *pparam = op->value.realval;	    break;        case t__invalid:	    return_error(e_stackunderflow);	default:	    return_error(e_typecheck);    }    return 0;}

/* <int> not <int> */intznot(i_ctx_t *i_ctx_p){    os_ptr op = osp;    switch (r_type(op)) {	case t_boolean:	    op->value.boolval = !op->value.boolval;	    break;	case t_integer:	    op->value.intval = ~op->value.intval;	    break;	default:	    return_op_typecheck(op);    }    return 0;}

/* float_params doesn't bother to keep track of the mask. */intfloat_params(const ref * op, int count, float *pval){    for (pval += count; --count >= 0; --op)	switch (r_type(op)) {	    case t_real:		*--pval = op->value.realval;		break;	    case t_integer:		*--pval = (float)op->value.intval;		break;	    case t__invalid:		return_error(e_stackunderflow);	    default:		return_error(e_typecheck);	}    return 0;}

/* Encode a character. */gs_glyphzfont_encode_char(gs_font *pfont, gs_char chr, gs_glyph_space_t gspace){    font_data *pdata = pfont_data(pfont);    const ref *pencoding = &pdata->Encoding;    ulong index = chr;	/* work around VAX widening bug */    ref cname;    int code = array_get(pfont->memory, pencoding, (long)index, &cname);    if (code < 0 || !r_has_type(&cname, t_name))        return gs_no_glyph;    if (pfont->FontType == ft_user_defined && r_type(&pdata->BuildGlyph) == t_null) {        ref nsref, tname;        name_string_ref(pfont->memory, &cname, &nsref);        if (r_size(&nsref) == 7 &&            !memcmp(nsref.value.const_bytes, ".notdef", r_size(&nsref))) {            /* A special support for high level devices.               They need a glyph name but the font doesn't provide one               due to an instandard BuildChar.               Such fonts don't conform to PLRM section 5.3.7,               but we've got real examples that we want to handle (Bug 686982).               Construct a name here.               Low level devices don't pass here, because regular PS interpretation               doesn't need such names.            */            char buf[20];            int code;            if (gspace == GLYPH_SPACE_NOGEN)                return gs_no_glyph;            sprintf(buf, "j%ld", chr); /* 'j' is arbutrary. */            code = name_ref(pfont->memory, (const byte *)buf, strlen(buf), &tname, 1);            if (code < 0) {                /* Can't propagate the error due to interface limitation,                   return with .notdef */            } else                cname = tname;        }    }    return (gs_glyph)name_index(pfont->memory, &cname);}

/* a missing value will return e_undefined rather than 1. */intdict_int_null_param(const ref * pdict, const char *kstr, int minval,                    int maxval, int defaultval, int *pvalue){    ref *pdval;    int code, ival;    if (pdict == 0 || dict_find_string(pdict, kstr, &pdval) <= 0) {        ival = defaultval;        code = 1;    } else {        switch (r_type(pdval)) {            case t_integer:                ival = pdval->value.intval;                break;            case t_real:                /* Allow an integral real, because Fontographer */                /* (which violates the Adobe specs in other ways */                /* as well) sometimes generates output that */                /* needs this. */                if (pdval->value.realval < minval || pdval->value.realval > maxval)                    return_error(e_rangecheck);                ival = (long)pdval->value.realval;                if (ival != pdval->value.realval)                    return_error(e_rangecheck);                break;            case t_null:                return 2;            default:                return_error(e_typecheck);        }        code = 0;    }    if (ival < minval || ival > maxval) {        if (code == 1)            return_error(e_undefined);        else            return_error(e_rangecheck);    }    *pvalue = (int)ival;    return code;}

/* <int1> <int2> xor <int> */intzxor(i_ctx_t *i_ctx_p){    os_ptr op = osp;    switch (r_type(op)) {	case t_boolean:	    check_type(op[-1], t_boolean);	    op[-1].value.boolval ^= op->value.boolval;	    break;	case t_integer:	    check_type(op[-1], t_integer);	    op[-1].value.intval ^= op->value.intval;	    break;	default:	    return_op_typecheck(op);    }    pop(1);    return 0;}

/* Return 0 if found, 1 if defaulted, <0 if wrong type. */intdict_float_param(const ref * pdict, const char *kstr,                 floatp defaultval, float *pvalue){    ref *pdval;    if (pdict == 0 || dict_find_string(pdict, kstr, &pdval) <= 0) {        *pvalue = defaultval;        return 1;    }    switch (r_type(pdval)) {        case t_integer:            *pvalue = (float)pdval->value.intval;            return 0;        case t_real:            *pvalue = pdval->value.realval;            return 0;    }    return_error(e_typecheck);}

/* See idparam.h for specification. */intdict_int_array_check_param(const gs_memory_t *mem, const ref * pdict,   const char *kstr, uint len, int *ivec, int under_error, int over_error){    ref pa, *pdval;    uint size;    int i, code;    if (pdict == 0 || dict_find_string(pdict, kstr, &pdval) <= 0)        return 0;    if (!r_is_array(pdval))        return_error(e_typecheck);    size = r_size(pdval);    if (size > len)        return_error(over_error);    for (i = 0; i < size; i++) {        code = array_get(mem, pdval, i, &pa);        if (code < 0)            return code;        /* See dict_int_param above for why we allow reals here. */        switch (r_type(&pa)) {            case t_integer:                if (pa.value.intval != (int)pa.value.intval)                    return_error(e_rangecheck);                ivec[i] = (int)pa.value.intval;                break;            case t_real:                if (pa.value.realval < min_int ||                    pa.value.realval > max_int ||                    pa.value.realval != (int)pa.value.realval                    )                    return_error(e_rangecheck);                ivec[i] = (int)pa.value.realval;                break;            default:                return_error(e_typecheck);        }    }    return (size == len || under_error >= 0 ? size :            gs_note_error(under_error));}

/* Clear the relocation for a ref object. */static voidrefs_clear_reloc(obj_header_t *hdr, uint size){    ref_packed *rp = (ref_packed *) (hdr + 1);    ref_packed *end = (ref_packed *) ((byte *) rp + size);    while (rp < end) {	if (r_is_packed(rp))	    rp++;	else {	    /* Full-size ref.  Store the relocation here if possible. */	    ref *const pref = (ref *)rp;	    if (!ref_type_uses_size_or_null(r_type(pref))) {		if_debug1('8', "  [8]clearing reloc at 0x%lx/n", (ulong) rp);		r_set_size(pref, 0);	    }	    rp += packed_per_ref;	}    }}

/* * Set *pchars and *plen to point to the data of a name or string, and * return 0.  If the object isn't a name or string, return e_typecheck. * If the object is a string without read access, return e_invalidaccess. */intobj_string_data(const gs_memory_t *mem, const ref *op, const byte **pchars, uint *plen){    switch (r_type(op)) {    case t_name: {	ref nref;	name_string_ref(mem, op, &nref);	*pchars = nref.value.bytes;	*plen = r_size(&nref);	return 0;    }    case t_string:	check_read(*op);	*pchars = op->value.bytes;	*plen = r_size(op);	return 0;    default:	return_error(e_typecheck);    }}

void test_add(){	printf("===test ADD===/n");	struct cpu_struct cpu;	memset(&cpu, 0, sizeof(cpu));	cpu.current_ins.rs = 1;	cpu.current_ins.rt = 2;	cpu.current_ins.rd = 3;	cpu.current_ins.funct = 0x20;	int i;	for (i = 0; i < 100; i++) {		int a = rand();		int b = rand();		cpu.reg[1] = a;		cpu.reg[2] = b;		r_type(&cpu);		printf("%d + %d: %d/n", a, b, cpu.reg[3]);		assert(cpu.reg[3] == a+b);	}	printf("pass/n/n");}

/* or an error if the format is invalid. */intnum_array_get(const ref *op, int format, uint index, ref *np){	if ( format == num_array )	  {	int code = array_get(op, (long)index, np);		if ( code < 0 )		  return t_null;		switch ( r_type(np) )		  {		  case t_integer:			return t_integer;		  case t_real:			return t_real;		  default:			return_error(e_rangecheck);		  }	  }	else	  {	uint nbytes = encoded_number_bytes(format);		if ( index >= (r_size(op) - 4) / nbytes )		  return t_null;		return sdecode_number(op->value.bytes + 4 + index * nbytes,				      format, np);	  }}