erlv8_set.cc

#include "erlv8.hh"

TickHandler(SetTickHandler) {
  ErlNifEnv *tmp_env = enif_alloc_env();
  ERL_NIF_TERM value = enif_make_copy(tmp_env, array[3]); // stashing it away since Set() might call an accessor, which might change vm->env
  val_res_t *obj_res;
  if (enif_get_resource(vm->env,array[1],val_resource,(void **)(&obj_res))) {
	LHCS(vm->isolate, obj_res->ctx);

	v8::PropertyAttribute property_attribute = v8::None;

	if (arity == 5) {
	  property_attribute = term_to_property_attribute(vm->env,array[4]);
	}
	
	obj_res->val->ToObject()->Set(term_to_js(obj_res->ctx, vm->isolate, vm->env,array[2]),term_to_js(obj_res->ctx, vm->isolate, tmp_env,value), property_attribute);
	
	SEND(vm->server,
		 enif_make_tuple3(env,
				  enif_make_atom(env,"result"),
				  enif_make_copy(env,tick_ref),
				  enif_make_copy(env,value)));
  } 
  enif_free_env(tmp_env);
  TickHandlerResolution result;
  result.type = DONE;
  return result;
}

TickHandler(SetProtoTickHandler) {
  val_res_t *obj_res;
  if (enif_get_resource(vm->env,array[1],val_resource,(void **)(&obj_res))) {
	LHCS(vm->isolate, obj_res->ctx);

    const char *atom_val = obj_res->val->ToObject()->SetPrototype(term_to_js(obj_res->ctx,vm->isolate,vm->env,array[2])) ? "true" : "false";
	
	SEND(vm->server,
		 enif_make_tuple3(env,
						  enif_make_atom(env,"result"),
						  enif_make_copy(env,tick_ref),
						  enif_make_atom(env,atom_val)));
  } 
  TickHandlerResolution result;
  result.type = DONE;
  return result;
}

TickHandler(SetHiddenTickHandler) {
  val_res_t *obj_res;
  if (enif_get_resource(vm->env,array[1],val_resource,(void **)(&obj_res))) {
	LHCS(vm->isolate, obj_res->ctx);

	obj_res->val->ToObject()->SetHiddenValue(term_to_js(obj_res->ctx, vm->isolate, vm->env,array[2])->ToString(),term_to_js(obj_res->ctx,vm->isolate, vm->env,array[3]));
	
	SEND(vm->server,
	     enif_make_tuple3(env,
			      enif_make_atom(env,"result"),
			      enif_make_copy(env,tick_ref),
			      enif_make_copy(env,array[2])));
  } 
  TickHandlerResolution result;
  result.type = DONE;
  return result;
}

TickHandler(SetInternalTickHandler) {
  val_res_t *obj_res;
  char name[MAX_ATOM_LEN];
  unsigned len;

  if (enif_get_resource(vm->env,array[1],val_resource,(void **)(&obj_res))) {
	LHCS(vm->isolate, obj_res->ctx);

	int index;
	enif_get_int(vm->env, array[2], &index);

	if (index < 0 || (index + 1 > obj_res->val->ToObject()->InternalFieldCount())) {
	  		SEND(vm->server,
			 enif_make_tuple3(env,
							  enif_make_atom(env,"result"),
							  enif_make_copy(env,tick_ref),
							  enif_make_atom(env,"error")));
	} else {

	  if (!strcmp(tick_name,"set_internal_extern")) {
		enif_get_atom_length(vm->env, array[4], &len, ERL_NIF_LATIN1);
		enif_get_atom(vm->env,array[4],(char *)&name,len + 1, ERL_NIF_LATIN1);
		v8::Handle<v8::Object> proto = extern_name_to_proto(vm, name);
		obj_res->val->ToObject()->SetInternalField(index,term_to_external(array[3]));
	  } else {
		obj_res->val->ToObject()->SetInternalField(index,term_to_js(obj_res->ctx,vm->isolate, vm->env,array[3]));
	  }
	  
	  SEND(vm->server,
		   enif_make_tuple3(env,
							enif_make_atom(env,"result"),
							enif_make_copy(env,tick_ref),
						  enif_make_copy(env,array[3])));
	} 
  }
  TickHandlerResolution result;
  result.type = DONE;
  return result;
}

v8::Handle<v8::Value> GetterFun(v8::Local<v8::String> property,const v8::AccessorInfo &info); // fwd
void SetterFun(v8::Local<v8::String> property,v8::Local<v8::Value> value,const v8::AccessorInfo &info); // fwd

void weak_accessor_data_cleaner(v8::Persistent<v8::Value> object, void * data) {
  if (object.IsNearDeath()) {
	object->ToObject()->DeleteHiddenValue(v8::String::New("_getter"));
	object->ToObject()->DeleteHiddenValue(v8::String::New("_setter"));
        object.Dispose();
        object.Clear();
  }
}

TickHandler(SetAccessorTickHandler) {
  char aname[MAX_ATOM_LEN];
  const char *atom_val;
  val_res_t *obj_res;
  if (enif_get_resource(vm->env,array[1],val_resource,(void **)(&obj_res))) {
	LHCS(vm->isolate, obj_res->ctx);

	if (arity > 3) {
	  v8::Handle<v8::Value> name = term_to_js(obj_res->ctx,vm->isolate, vm->env,array[2]);
	  if (!name->IsString()) {
          goto badarg;
      }
	  v8::AccessorGetter getter = GetterFun;
	  v8::AccessorSetter setter = 0;
	  v8::Persistent<v8::Object> data = v8::Persistent<v8::Object>::New(v8::Object::New());
	  data.MakeWeak(NULL,weak_accessor_data_cleaner); // so that we'll release externals when we're done

	  if (term_to_js(obj_res->ctx,vm->isolate, vm->env,array[3])->IsUndefined()) {
          goto badarg;
	  } else {
		data->SetHiddenValue(v8::String::New("_getter"), term_to_external(array[3]));
	  }

	  if (arity > 4) {
		setter = SetterFun;
		data->SetHiddenValue(v8::String::New("_setter"), term_to_external(array[4]));
	  }

	  v8::AccessControl access_control = v8::DEFAULT;
   
	  if (arity > 5 && enif_is_atom(vm->env, array[5])) {
		unsigned len;
		enif_get_atom_length(vm->env, array[5], &len, ERL_NIF_LATIN1);
		enif_get_atom(vm->env,array[5], (char *) &aname,len + 1, ERL_NIF_LATIN1);
		if (!strcmp(aname,"default")) {
		  access_control = v8::DEFAULT;
		} else if (!strcmp(aname,"all_can_read")) {
		  access_control = v8::ALL_CAN_READ;
		} else if (!strcmp(aname,"all_can_write")) {
		  access_control = v8::ALL_CAN_WRITE;
		} else if (!strcmp(aname,"prohibits_overwriting")) {
		  access_control = v8::PROHIBITS_OVERWRITING;
		}
	  }

	  v8::PropertyAttribute property_attribute = v8::None;
   
	  if (arity > 6) {
		property_attribute = term_to_property_attribute(vm->env,array[6]);
	  }

      atom_val = obj_res->val->ToObject()->SetAccessor(name->ToString(), getter, setter, data,
																   access_control, property_attribute) ? "true" : "false";
      goto send;
	}
badarg:
    atom_val = "badarg";
send:
	SEND(vm->server,
		 enif_make_tuple3(env,
						  enif_make_atom(env,"result"),
						  enif_make_copy(env,tick_ref),
						  enif_make_atom(env, atom_val)));
  } 
  TickHandlerResolution result;
  result.type = DONE;
  return result;
}



v8::Handle<v8::Value> GetterFun(v8::Local<v8::String> property,const v8::AccessorInfo &info) {
  v8::HandleScope handle_scope;
  VM * vm = (VM *)__ERLV8__(v8::Context::GetCurrent()->Global());

  v8::Local<v8::Object> data = info.Data()->ToObject();
  
  // each call gets a unique ref
  ERL_NIF_TERM ref = enif_make_ref(vm->env);

  // prepare arguments
  ERL_NIF_TERM *arr = (ERL_NIF_TERM *) malloc(sizeof(ERL_NIF_TERM) * 1);
  arr[0] = js_to_term(vm->context, vm->isolate, vm->env, property);
  ERL_NIF_TERM arglist = enif_make_list_from_array(vm->env,arr,1);
  free(arr);

  // send invocation request
  SEND(vm->server,
	   enif_make_tuple3(env,
						enif_make_copy(env,external_to_term(data->GetHiddenValue(v8::String::New("_getter")))),
						enif_make_tuple7(env, 
										 enif_make_atom(env,"erlv8_fun_invocation"),
										 enif_make_atom(env,"false"),
										 js_to_term(vm->context, vm->isolate, env, info.Holder()),
										 js_to_term(vm->context, vm->isolate, env, info.This()),
										 enif_make_copy(env, ref),
										 enif_make_pid(env, vm->server),
										 enif_make_copy(env, external_to_term(v8::Context::GetCurrent()->Global()->GetHiddenValue(v8::String::New("__erlv8__ctx__"))))
										 ),
						enif_make_copy(env,arglist)));
  return handle_scope.Close(vm->ticker(ref));  
}

void SetterFun(v8::Local<v8::String> property,v8::Local<v8::Value> value,const v8::AccessorInfo &info) {
  v8::HandleScope handle_scope;
  VM * vm = (VM *)__ERLV8__(v8::Context::GetCurrent()->Global());

  v8::Local<v8::Object> data = info.Data()->ToObject();

  // each call gets a unique ref
  ERL_NIF_TERM ref = enif_make_ref(vm->env);

  // prepare arguments
  ERL_NIF_TERM *arr = (ERL_NIF_TERM *) malloc(sizeof(ERL_NIF_TERM) * 2);
  arr[0] = js_to_term(vm->context, vm->isolate, vm->env, property);
  arr[1] = js_to_term(vm->context, vm->isolate, vm->env, value);
  ERL_NIF_TERM arglist = enif_make_list_from_array(vm->env,arr,2);
  free(arr);

  // send invocation request
  SEND(vm->server,
	   enif_make_tuple3(env,
						enif_make_copy(env,external_to_term(data->GetHiddenValue(v8::String::New("_setter")))),
						enif_make_tuple7(env, 
										 enif_make_atom(env,"erlv8_fun_invocation"),
										 enif_make_atom(env,"false"),
										 js_to_term(vm->context, vm->isolate, env, info.Holder()),
										 js_to_term(vm->context, vm->isolate, env, info.This()),
										 enif_make_copy(env, ref),
										 enif_make_pid(env, vm->server),
										 enif_make_copy(env, external_to_term(v8::Context::GetCurrent()->Global()->GetHiddenValue(v8::String::New("__erlv8__ctx__"))))
										 ),
						enif_make_copy(env,arglist)));
  vm->ticker(ref);  
}