static void
ofpath_begin_mask(fz_device *dev, fz_rect bbox, int luminosity, fz_colorspace *colorspace, float *color)
{
	NOT_IMPL();
}

static void
ofpath_clip_image_mask(fz_device *dev, fz_image *image, fz_rect *rect, fz_matrix ctm)
{
	NOT_IMPL();
}

static void
ofpath_pop_clip(fz_device *dev)
{
	NOT_IMPL();
}

int
guestfs_impl_add_domain (guestfs_h *g, const char *dom,
                     const struct guestfs_add_domain_argv *optargs)
{
  NOT_IMPL(-1);
}

		DEMO_ENTRY_NAME(ease, EaseBounceOutTest),
		DEMO_ENTRY_NAME(ease, EaseElasticInOutTest),
		DEMO_ENTRY_NAME(ease, EaseElasticInTest),
		DEMO_ENTRY_NAME(ease, EaseElasticOutTest),
		DEMO_ENTRY_NAME(ease, EaseExponentialInOutTest),
		DEMO_ENTRY_NAME(ease, EaseExponentialInTest),
		DEMO_ENTRY_NAME(ease, EaseExponentialOutTest),
		DEMO_ENTRY_NAME(ease, EaseInOutTest),
		DEMO_ENTRY_NAME(ease, EaseInTest),
		DEMO_ENTRY_NAME(ease, EaseOutTest),
		DEMO_ENTRY_NAME(ease, EaseSineInOutTest),
		DEMO_ENTRY_NAME(ease, EaseSineInTest),
		DEMO_ENTRY_NAME(ease, EaseSineOutTest),
	},
	{
		NOT_IMPL(DEMO_ENTRY_NAME(event, AccelerometerTest)),
		DEMO_ENTRY_NAME(event, CharacterMoveTest),
		DEMO_ENTRY_NAME(event, ClickAndMoveTest),
		DEMO_ENTRY_NAME(event, DoubleTapTest),
		DEMO_ENTRY_NAME(event, GestureTest),
		DEMO_ENTRY_NAME(event, KeyTest),
		NOT_IMPL(DEMO_ENTRY_NAME(event, MultiTouchTest)),
		DEMO_ENTRY_NAME(event, CustomBackTest),
	},
	{
		DEMO_ENTRY_NAME(gridaction, GridFlipXTest),
		DEMO_ENTRY_NAME(gridaction, GridFlipYTest),
		DEMO_ENTRY_NAME(gridaction, JumpTiles3DTest),
		DEMO_ENTRY_NAME(gridaction, Lens3DTest),
		DEMO_ENTRY_NAME(gridaction, LineShrinkOutTest),
		DEMO_ENTRY_NAME(gridaction, LiquidTest),

static void
ofpath_end_group(fz_device *dev)
{
	NOT_IMPL();
}

static void
ofpath_end_tile(fz_device *dev)
{
	NOT_IMPL();
}

static void
ofpath_clip_text(fz_device *dev, fz_text *text, fz_matrix ctm, int accumulate)
{
	NOT_IMPL();
}

static void
ofpath_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm)
{
	NOT_IMPL();
}

static void
ofpath_clip_stroke_path(fz_device *dev, fz_path *path, fz_rect *rect, fz_stroke_state *stroke, fz_matrix ctm)
{
	NOT_IMPL();
}

static void
ofpath_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm,
				   fz_colorspace *colorspace, float *color, float alpha)
{
	NOT_IMPL();
}

static void
ofpath_clip_path(fz_device *dev, fz_path *path, fz_rect *rect, int even_odd, fz_matrix ctm)
{
	NOT_IMPL();
}

//.........这里部分代码省略.........

	sparc_st_imm_ptr (p, sparc_l0, sparc_sp,
		  (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, retval)));

	/* call ves_exec_method */
	sparc_add_imm (p, 0, sparc_sp, MINV_POS, sparc_o0);
	sparc_set_ptr (p, (void *)ves_exec_method, sparc_l0);
	sparc_jmpl_imm (p, sparc_l0, 0, sparc_callsite);
	sparc_nop (p);

	/* move retval from stackval to proper place (r3/r4/...) */
        if (sig->ret->byref) {
		sparc_ld_imm_ptr (p, sparc_sp, stackval_arg_pos, sparc_i0 );
        } else {
        enum_retvalue:
                switch (sig->ret->type) {
                case MONO_TYPE_VOID:
                        break;
                case MONO_TYPE_BOOLEAN:
                case MONO_TYPE_I1:
                case MONO_TYPE_U1:
                case MONO_TYPE_I2:
                case MONO_TYPE_U2:
                case MONO_TYPE_I4:
                case MONO_TYPE_U4:
                        sparc_ld_imm (p, sparc_sp, stackval_arg_pos, sparc_i0);
                        break;
                case MONO_TYPE_I:
                case MONO_TYPE_U:
                case MONO_TYPE_OBJECT:
		case MONO_TYPE_STRING:
                case MONO_TYPE_CLASS:
                        sparc_ld_imm_ptr (p, sparc_sp, stackval_arg_pos, sparc_i0);
                        break;
                case MONO_TYPE_I8:
                case MONO_TYPE_U8:
#if SPARCV9
                        sparc_ldx_imm (p, sparc_sp, stackval_arg_pos, sparc_i0);
#else
                        sparc_ld_imm (p, sparc_sp, stackval_arg_pos, sparc_i0);
                        sparc_ld_imm (p, sparc_sp, stackval_arg_pos + 4, sparc_i1);
#endif
                        break;
                case MONO_TYPE_R4:
                        sparc_lddf_imm (p, sparc_sp, stackval_arg_pos, sparc_f0);
			sparc_fdtos(p, sparc_f0, sparc_f0);
                        break;
                case MONO_TYPE_R8:
                        sparc_lddf_imm (p, sparc_sp, stackval_arg_pos, sparc_f0);
                        break;
                case MONO_TYPE_VALUETYPE: {
			gint size;
			gint reg = sparc_i0;
                        if (sig->ret->data.klass->enumtype) {
                                simpletype = sig->ret->data.klass->enum_basetype->type;
                                goto enum_retvalue;
                        }
#if SPARCV9
                        size = mono_class_native_size (sig->ret->data.klass, NULL);
                        sparc_ldx_imm (p, sparc_sp, stackval_arg_pos, sparc_l0);
			if (size <= 16) {
				gint off = 0;
				if (size >= 8) {
		                        sparc_ldx_imm (p, sparc_l0, 0, reg);
					size -= 8;
					off += 8;
					reg++;
				}
				if (size > 0)
		                        sparc_ldx_imm (p, sparc_l0, off, reg);
			} else
	                        NOT_IMPL("value type as ret val from delegate");
#endif
                        break;
		}
                default: 
			g_error ("Type 0x%x not handled yet in thunk creation",
				 sig->ret->type);
                        break;
                }
        }

	p = emit_epilog (p, sig, stack_size);

	for (i = 0; i < ((p - code_buffer)/2); i++)
		flushi((code_buffer + (i*8)));
	
	ji = g_new0 (MonoJitInfo, 1);
        ji->method = method;
        ji->code_size = p - code_buffer;
	ji->code_start = code_buffer;
	
	mono_jit_info_table_add (mono_get_root_domain (), ji);

	DEBUG(sparc_disassemble_code (code_buffer, p, method->name));

	DEBUG(fprintf(stderr, "Delegate [end emiting] %s\n", method->name));

	return ji->code_start;
}

void frm_isa_FCMP_impl(struct frm_thread_t *thread, struct frm_inst_t *inst)
{
	NOT_IMPL();
}

static void
ofpath_end_mask(fz_device *dev)
{
	NOT_IMPL();
}

static void
ofpath_ignore_text(fz_device *dev, fz_text *text, fz_matrix ctm)
{
	NOT_IMPL();
}

static void
ofpath_begin_group(fz_device *dev, fz_rect bbox, int isolated, int knockout, int blendmode, float alpha)
{
	NOT_IMPL();
}

static void
ofpath_fill_image(fz_device *dev, fz_image *image, fz_matrix ctm, float alpha)
{
	NOT_IMPL();
}

static void
ofpath_begin_tile(fz_device *dev, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm)
{
	NOT_IMPL();
}

static void
ofpath_fill_shade(fz_device *dev, fz_shade *shade, fz_matrix ctm, float alpha)
{
	NOT_IMPL();
}