예제 #1
0
value caml_vc_funType3(value vc, value a1, value a2, value a3, value tr)
{
  CAMLparam5(vc,a1,a2,a3,tr);
  CAMLreturn(alloc_Type(vc_funType3(VC_val(vc),Type_val(a1),
				    Type_val(a2),Type_val(a3),
				    Type_val(tr))));
}
예제 #2
0
CAMLprim value ocamlyices_type_tuple2(value v_tau1, value v_tau2) {
  CAMLparam2(v_tau1, v_tau2);
  type_t res;

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

  CAMLreturn(Val_type(res));
}
예제 #3
0
CAMLprim value ocamlyices_type_function1(value v_dom1, value v_range) {
  CAMLparam2(v_dom1, v_range);
  type_t res;

  res = yices_function_type1(Type_val(v_dom1), Type_val(v_range));
  if (res == NULL_TYPE) {
    _oy_error();
  }

  CAMLreturn(Val_type(res));
}
예제 #4
0
CAMLprim value ocamlyices_type_is_subtype(value v_t1, value v_t2) {
  CAMLparam2(v_t1, v_t2);
  int32_t res;

  res = yices_test_subtype(Type_val(v_t1), Type_val(v_t2));
  if (res == 0) {
    _oy_check_error();
  }

  CAMLreturn(Val_bool(res != 0));
}
예제 #5
0
value caml_vc_recordTypeN(value vc, value fields, value types, value num)
{
  char **fs;
  Type *ts;
  int i;

  CAMLparam4(vc,fields,types,num);
  CAMLlocal1(result);

  fs = (char **)malloc(Int_val(num) * sizeof(char *));
  if( !fs )
    caml_failwith("malloc returned NULL in vc_recordTypeN wrapper");

  ts = (Type *)malloc(Int_val(num) * sizeof(Type));
  if( !ts ) {
    free( fs );
    caml_failwith("malloc returned NULL in vc_recordTypeN wrapper");
  }

  for( i = 0; i < Int_val(num); i++ ) {
    fs[i] = String_val(Field(fields,i));
    ts[i] = Type_val(Field(types,i));
  }

  result = alloc_Type(vc_recordTypeN(VC_val(vc),fs,ts,Int_val(num)));

  free(ts);
  free(fs);

  CAMLreturn(result);
}
예제 #6
0
static inline value _oy_bool_of_type (int32_t (*f) (type_t), value v_t) {
  CAMLparam1(v_t);
  int32_t res = f(Type_val(v_t));
  if (res == 0) {
    _oy_check_error();
  }
  CAMLreturn(Val_bool(res));
}
예제 #7
0
// Convertsa Type to a string
value caml_typeString(value t)
{
  CAMLparam1(t);
  CAMLlocal1(r);

  r = caml_copy_string(typeString(Type_val(t)));

  CAMLreturn(r);
}
예제 #8
0
static inline type_t *_oy_types_from_values(value v_arr, uint32_t n) {
  uint32_t i;
  type_t *arr = (type_t *)malloc(sizeof(type_t[n]));
  if (arr) {
    for (i = 0; i < n; i++) {
      arr[i] = Type_val(Field(v_arr, i));
    }
  }
  return arr;
}
예제 #9
0
CAMLprim value ocamlyices_type_clear_name (value v_typ) {
  // Hyp: type values are non-block
  int32_t res;

  res = yices_clear_type_name(Type_val(v_typ));
  if (res != 0) {
    _oy_error();
  }

  return Val_unit;
}
예제 #10
0
CAMLprim value ocamlyices_type_get_name (value v_typ) {
  // Hyp: type values are non-block
  const char *res;

  res = yices_get_type_name(Type_val(v_typ));
  if (res == NULL) {
    _oy_error();
  }

  return caml_copy_string(res);
}
예제 #11
0
CAMLprim value ocamlyices_type_tuple1(value v_tau1) {
  CAMLparam1(v_tau1);
  type_t res;

  res = yices_tuple_type1(Type_val(v_tau1));
  if (res == NULL_TYPE) {
    _oy_error();
  }

  CAMLreturn(Val_type(res));
}
예제 #12
0
CAMLprim value ocamlyices_type_set_name (value v_t, value v_name) {
  // Hyp: type values are non-block
  CAMLparam1(v_name);
  int32_t res;

  res = yices_set_type_name(Type_val(v_t), String_val(v_name));
  if (res != 0) {
    _oy_error();
  }

  CAMLreturn(Val_unit);
}
예제 #13
0
CAMLprim value ocamlyices_type_print(value v_width_opt, value v_height_opt,
                                     value v_offset_opt, value v_cb, value v_t) {
  CAMLparam4(v_width_opt, v_height_opt, v_offset_opt, v_cb);
  type_t t = Type_val(v_t);
  uint32_t width = (uint32_t)Long_option_val(v_width_opt, UINT32_MAX);
  uint32_t height = (uint32_t)Long_option_val(v_height_opt, 1);
  uint32_t offset = (uint32_t)Long_option_val(v_offset_opt, 0);
  struct pp_type_arg arg = { t, width, height, offset };
  int res = _oy_callback_print(v_cb, &_oy_type_pp, &arg);
  if (res != 0) {
    _oy_error();
  }
  CAMLreturn(Val_unit);
}
예제 #14
0
value caml_vc_funTypeN(value vc, value args, value r, value num)
{
  Type *ts;
  int i;

  CAMLparam4(vc,args,r,num);
  CAMLlocal1(result);

  ts = (Type *)malloc(Int_val(num) * sizeof(Type));
  if( !ts )
    caml_failwith("malloc returned NULL in vc_funTypeN wrapper");

  for( i = 0; i < Int_val(num); i++ ) {
    ts[i] = Type_val(Field(args,i));
  }

  result = alloc_Type(vc_funTypeN(VC_val(vc), ts, Type_val(r),
				  Int_val(num)));

  free( ts );

  CAMLreturn(result);
}
예제 #15
0
CAMLprim value ocamlyices_type_bitsize (value v_typ) {
  // Hyp: type values are non-block

  uint32_t bitsize = yices_bvtype_size(Type_val(v_typ));
  if (bitsize == 0) {
    _oy_error();
  }

  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wtype-limits"
  if (YICES_MAX_BVSIZE > Max_long /* should not happen */ &&
      bitsize > Max_long /* only possible on <= 64-bit system */) {
  #pragma GCC diagnostic pop
    _oy_binding_overflow_error();
  }

  return Val_long((intnat)bitsize);
}
예제 #16
0
CAMLprim value ocamlyices_type_function (value v_dom, value v_range) {
  CAMLparam2(v_dom, v_range);
  type_t res, *dom;
  uint32_t n;

  n = check_Wosize_val(v_dom);
  dom = _oy_types_from_values(v_dom, n);
  if (dom == NULL) {
    _oy_allocation_error();
  }

  res = yices_function_type(n, dom, Type_val(v_range));
  free(dom);

  if (res == NULL_TYPE) {
    _oy_error();
  }

  CAMLreturn(Val_type(res));
}
예제 #17
0
value caml_vc_tupleTypeN(value vc, value types, value numTypes)
{
  Type *ts;
  int i;

  CAMLparam3(vc,types,numTypes);
  CAMLlocal1(result);

  ts = (Type *)malloc(Int_val(numTypes) * sizeof(Type));
  if( !ts )
    caml_failwith("malloc returned NULL in vc_tupleTypeN wrapper");

  for( i = 0; i < Int_val(numTypes); i++ ) {
    ts[i] = Type_val(Field(types,i));
  }

  result = alloc_Type(vc_tupleTypeN(VC_val(vc), ts, Int_val(numTypes)));

  free( ts );

  CAMLreturn(result);
}
예제 #18
0
value caml_vc_recordType2(value vc, value f0, value t0, value f1, value t1)
{
  CAMLparam5(vc,f0,t0,f1,t1);
  CAMLreturn(alloc_Type(vc_recordType2(VC_val(vc),String_val(f0),Type_val(t0),
				       String_val(f1),Type_val(t1))));
}
예제 #19
0
// Create an array type
value caml_vc_arrayType(value vc, value it, value dt)
{
  CAMLparam3(vc,it,dt);
  CAMLreturn(alloc_Type(vc_arrayType(VC_val(vc),Type_val(it),Type_val(dt))));
}
예제 #20
0
static value alloc_Type(Type t)
{
  value v = alloc_custom(&Type_ops, sizeof(Type), 0, 1);
  Type_val(v) = t;
  return v;
}
예제 #21
0
// Create function types
value caml_vc_funType1(value vc, value a1, value tr)
{
  CAMLparam3(vc,a1,tr);
  CAMLreturn(alloc_Type(vc_funType1(VC_val(vc),Type_val(a1),Type_val(tr))));
}
예제 #22
0
value caml_vc_funType2(value vc, value a1, value a2, value tr)
{
  CAMLparam4(vc,a1,a2,tr);
  CAMLreturn(alloc_Type(vc_funType2(VC_val(vc),Type_val(a1),
				    Type_val(a2),Type_val(tr))));
}
예제 #23
0
value caml_vc_deleteType(value type)
{
  CAMLparam1(type);
  vc_deleteType(Type_val(type));
  CAMLreturn(Val_unit);
}
예제 #24
0
value caml_toExpr(value t)
{
  CAMLparam1(t);
  CAMLreturn(alloc_Expr(toExpr(Type_val(t))));
}
예제 #25
0
// Tuple Types
value caml_vc_tupleType2(value vc, value t0, value t1)
{
  CAMLparam3(vc,t0,t1);
  CAMLreturn(alloc_Type(vc_tupleType2(VC_val(vc),Type_val(t0),Type_val(t1))));
}
예제 #26
0
// Record Types
value caml_vc_recordType1(value vc, value field, value t)
{
  CAMLparam3(vc, field, t);
  CAMLreturn(alloc_Type(vc_recordType1(VC_val(vc),String_val(field),
				       Type_val(t))));
}
예제 #27
0
value caml_vc_tupleType3(value vc, value t0, value t1, value t2)
{
  CAMLparam4(vc,t0,t1,t2);
  CAMLreturn(alloc_Type(vc_tupleType3(VC_val(vc),Type_val(t0),
				      Type_val(t1),Type_val(t2))));
}
예제 #28
0
// Get the expression and type associated with a name
value caml_vc_lookupVar(value vc, value name, value t)
{
  CAMLparam3(vc,name,t);
  CAMLreturn(alloc_Expr(vc_lookupVar(VC_val(vc),String_val(name),Type_val(t))));
}