C++ CAMLparam3函数代码示例

CAMLprim value stub_asl_set(value m, value key, value val) {
  CAMLparam3(m, key, val);
  const char *c_key = strdup(String_val(key));
  const char *c_val = strdup(String_val(val));
  caml_release_runtime_system();
  asl_set(Msg_val(m), c_key, c_val);
  caml_acquire_runtime_system();
  free((void*)c_key);
  free((void*)c_val);
  CAMLreturn(0);
}

CAMLprim value stub_atomic_fetch_and_uint8(value buf, value idx, value val)
{
  CAMLparam3(buf, idx, val);
  uint8_t c_val = (uint8_t)Int_val(val);
  uint8_t *ptr = Caml_ba_data_val(buf) + Int_val(idx);

  if (Int_val(idx) >= Caml_ba_array_val(buf)->dim[0])
    caml_invalid_argument("idx");

  CAMLreturn(Val_int((uint8_t)__sync_fetch_and_and(ptr, c_val)));
}

value caml_curses_wmove(value mlwindow, value y, value x) {

   CAMLparam3(mlwindow, y, x);
   WINDOW *window = window_of_ml(mlwindow);
   
   /* Move the cursor in the indicated window */
   wmove(window, Int_val(y), Int_val(x));
   
   CAMLreturn(Val_unit);

}

CAMLprim value
caml_gnttab_read(value v_gw, value v_off, value v_size)
{
    CAMLparam3(v_gw, v_off, v_size);
    CAMLlocal1(v_ret);
    gnttab_wrap *gw = Gnttab_wrap_val(v_gw);
    BUG_ON(gw->page == NULL);
    v_ret = caml_alloc_string(Int_val(v_size));
    memcpy(String_val(v_ret), gw->page + Int_val(v_off), Int_val(v_size));
    CAMLreturn(v_ret);
}

value
v2v_xml_node_ptr_set_prop (value nodev, value namev, value valv)
{
  CAMLparam3 (nodev, namev, valv);
  xmlNodePtr node = (xmlNodePtr) nodev;

  if (xmlSetProp (node, BAD_CAST String_val (namev), BAD_CAST String_val (valv))
      == NULL)
    caml_invalid_argument ("node_ptr_set_prop: failed to set property");

  CAMLreturn (Val_unit);
}

CAMLprim value win_putenv(value var, value wvar, value v)
{
  BOOL res;
  CAMLparam3(var, wvar, v);

  res = SetEnvironmentVariableW((LPCWSTR) String_val(wvar), (LPCWSTR) v);
  if (res == 0) {
    win32_maperr (GetLastError ());
    uerror("putenv", var);
  }
  CAMLreturn (Val_unit);
}

value
create_tuple(value a, value b, value c){
  CAMLparam3(a,b,c);
  CAMLlocal1(tmp);
  tmp=caml_alloc(3,0); // allocate 3 tag 0 on ocaml heap

  Store_field(tmp,1,a);
  Store_field(tmp,2,a);
  Store_field(tmp,3,a);

  CAMLreturn(tmp);
}

CAMLprim value ml_gtk_text_buffer_get_iter_at_line_index(value tb, 
							 value l,
							 value c)
{
  CAMLparam3(tb,l,c);
  GtkTextIter res;
  gtk_text_buffer_get_iter_at_line_offset(GtkTextBuffer_val(tb),
					  &res,
					  Int_val(l),
					  Int_val(c));
  CAMLreturn(Val_GtkTextIter(&res));
}

value
sankoff_CAML_dist_2(value a, value b,value c) {
   CAMLparam3(a,b,c);
   eltarr_p eapD;
   eltarr_p eapA;
   eltarr_p eapR;
   eapD = Sankoff_return_eltarr(a);
   eapA = Sankoff_return_eltarr(b);
   eapR = Sankoff_return_eltarr(c);
   int res = sankoff_dist_2(eapD,eapA,eapR);
   CAMLreturn(Val_int(res));
}

PREFIX value ml_evas_object_smart_callback_add(
        value v_obj, value v_event, value v_func)
{
        CAMLparam3(v_obj, v_event, v_func);
        value* data = caml_stat_alloc(sizeof(value));
        *data = v_func;
        caml_register_global_root(data);
        const char* event = String_val(v_event);
        evas_object_smart_callback_add((Evas_Object*) v_obj, event,
	ml_Evas_Smart_Cb, data);
        CAMLreturn(Val_unit);
}

CAMLprim value Wrapper_FT_Load_Glyph(value face, value glyph_index, value load_flags)
{
  CAMLparam3(face, glyph_index, load_flags);
  FT_Face f;

  f = *(FT_Face *)Data_custom_val(face);

  if (FT_Load_Glyph(f, Int_val(glyph_index), Int_val(load_flags)))
    failwith("FT_Load_Glyph");

  CAMLreturn(Val_unit);
};

CAMLprim value ocamlyices_type_tuple3(value v_tau1, value v_tau2,
                                      value v_tau3) {
  CAMLparam3(v_tau1, v_tau2, v_tau3);
  type_t res;

  res = yices_tuple_type3(Type_val(v_tau1), Type_val(v_tau2), Type_val(v_tau3));
  if (res == NULL_TYPE) {
    _oy_error();
  }

  CAMLreturn(Val_type(res));
}

t_value ml_glgetactiveattrib (value program, value index, value bufsize)
{
	CAMLparam3 (program, index, bufsize);
	CAMLlocal1 (name);
	GLsizei len;
	GLint size;
	GLenum type;
	char *buffer = (char *)malloc (sizeof(char) * bufsize);
	glGetActiveAttrib (Long_val(program), Int_val(index), Int_val(bufsize), &len, &size, &type, buffer);
	name = caml_copy_string (buffer);
	CAMLreturn (name);
}

value
sankoff_CAML_init_beta (value this_elt, value position, value cost)
{
    CAMLparam3(this_elt,position,cost);
    elt_p ep;
    Sankoff_elt_custom_val(ep,this_elt);
    int pos, c;
    pos = Int_val(position);
    c = Int_val(cost);
    sankoff_set_beta(ep,pos,c);
    CAMLreturn (Val_unit);
}

CAMLprim value spoc_cuda_set_block_shape(value ker, value block, value gi){
	CAMLparam3(ker, block, gi);
	CUfunction *kernel;

	CUDA_GET_CONTEXT;

	kernel = (CUfunction*) ker;
	CUDA_CHECK_CALL(cuFuncSetBlockShape(*kernel, Int_val(Field(block,0)),Int_val(Field(block,1)),Int_val(Field(block,2))));

	CUDA_RESTORE_CONTEXT;
	CAMLreturn(Val_unit);
}