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

    DEFINE_FUNC_1(webp_decode_argb, data_buffer_value) {        if (!val_is_buffer(data_buffer_value)) {            val_throw(alloc_string("webp_decode_argb: Expected to be a buffer"));            return alloc_null();        }        buffer data_buffer = val_to_buffer(data_buffer_value);        int    data_len = buffer_size(data_buffer);        char  *data_ptr = buffer_data(data_buffer);        int webp_width = -1, webp_height = -1;        char *webp_data_ptr = (char *)WebPDecodeARGB((const unsigned char *)data_ptr, data_len, &webp_width, &webp_height);        int webp_data_len = webp_width * webp_height * 4;        if (webp_data_ptr == NULL) {            val_throw(alloc_string("webp_decode_argb: Invalid webp data"));            return alloc_null();        }        buffer webp_buffer = alloc_buffer_len(0);        buffer_append_sub(webp_buffer, webp_data_ptr, webp_data_len);        buffer_set_size(webp_buffer, webp_data_len);        value array = alloc_array(3);        val_array_set_i(array, 0, alloc_int(webp_width));        val_array_set_i(array, 1, alloc_int(webp_height));        val_array_set_i(array, 2, buffer_val(webp_buffer));        if (webp_data_ptr != NULL) free(webp_data_ptr);        return array;    }

value hxfcgi_get_cookies(value hreq) {	val_check_kind(hreq,hxRequest);	hxfcgi::BasicData d;	string ret = d.getHeader("COOKIE");	if (ret.compare("")==0)	return val_null;	char *k = (char*)ret.c_str();	char *start, *end;	value p = val_null, tmp;	while( (start = strchr(k,'=')) != NULL ) {		start++;		end = start;		while( *end != 0 && *end != '/r' && *end != '/n' && *end != ';' )			end++;		tmp = alloc_array(3);		val_array_set_i(tmp,0,copy_string(k,(int)(start-k-1)));		val_array_set_i(tmp,1,copy_string(start,(int)(end-start)));		val_array_set_i(tmp,2,p);		p = tmp;		if( *end != ';' || end[1] != ' ' )			break;		k = end + 2;	}	return p;}

static value socket_poll_alloc( value nsocks ) {	polldata *p;	int i;	val_check(nsocks,int);	p = (polldata*)malloc(sizeof(polldata));	p->max = val_int(nsocks);	if( p->max < 0 || p->max > 1000000 )		return alloc_null();#	ifdef NEKO_WINDOWS	{		p->fdr = (fd_set*)malloc(FDSIZE(p->max));		p->fdw = (fd_set*)malloc(FDSIZE(p->max));		p->outr = (fd_set*)malloc(FDSIZE(p->max));		p->outw = (fd_set*)malloc(FDSIZE(p->max));		p->fdr->fd_count = 0;		p->fdw->fd_count = 0;	}#	else	p->fds = (struct pollfd*)malloc(sizeof(struct pollfd) * p->max);	p->rcount = 0;	p->wcount = 0;#	endif	p->ridx = alloc_array(p->max+1);	p->widx = alloc_array(p->max+1);        val_gc_add_root(&p->ridx);        val_gc_add_root(&p->widx);	for(i=0;i<=p->max;i++) {		val_array_set_i(p->ridx,i, alloc_int(-1));		val_array_set_i(p->widx,i, alloc_int(-1));	}	value v = alloc_abstract(k_poll, p);        val_gc(v,free_sock);        return v;}

static void file_error( const char *msg, fio *f, bool delete_f = false ) {	gc_exit_blocking();	value a = alloc_array(2);	val_array_set_i(a,0,alloc_string(msg));	val_array_set_i(a,1,alloc_filename(f->name.c_str()));	if (delete_f)		delete f;	val_throw(a);}

value hxfcgi_get_params(value hreq) {	hxfcgi::Request *req = get_request(hreq);	hxfcgi::Data d;	map<string,string> params = d.getParams((*req));	value ret = alloc_array(params.size()*2);	unsigned int c = 0;	for (map<string,string>::iterator iter = params.begin(); iter!=params.end(); iter++, c++) {		val_array_set_i(ret,2*c,alloc_string(iter->first.c_str()));		val_array_set_i(ret,2*c+1,alloc_string(iter->second.c_str()));	}	return ret;}

/**	socket_host : 'socket -> #address	<doc>Return the socket local address composed of an (host,port) array</doc>**/static value socket_host( value o ) {	SOCKET sock = val_sock(o);	struct sockaddr_in addr;	SockLen addrlen = sizeof(addr);	value ret;	if( getsockname(sock,(struct sockaddr*)&addr,&addrlen) == SOCKET_ERROR )		return alloc_null();	ret = alloc_array(2);	val_array_set_i(ret,0,alloc_int32(*(int*)&addr.sin_addr));	val_array_set_i(ret,1,alloc_int(ntohs(addr.sin_port)));	return ret;}

	value lime_al_get_source3f (int source, int param) {				ALfloat val1, val2, val3;				alGetSource3f (source, param, &val1, &val2, &val3);				value result = alloc_array (3);		val_array_set_i (result, 0, alloc_float (val1));		val_array_set_i (result, 1, alloc_float (val2));		val_array_set_i (result, 2, alloc_float (val3));		return result;			}

	value lime_al_get_listener3f (int param) {				ALfloat val1, val2, val3;				alGetListener3f (param, &val1, &val2, &val3);				value result = alloc_array (3);		val_array_set_i (result, 0, alloc_float (val1));		val_array_set_i (result, 1, alloc_float (val2));		val_array_set_i (result, 2, alloc_float (val3));		return result;			}

	value lime_al_get_buffer3i (int buffer, int param) {				ALint val1, val2, val3;				alGetBuffer3i (buffer, param, &val1, &val2, &val3);				value result = alloc_array (3);		val_array_set_i (result, 0, alloc_int(val1));		val_array_set_i (result, 1, alloc_int(val2));		val_array_set_i (result, 2, alloc_int(val3));		return result;			}

value lime_al_get_listener3i (value param) {    ALint val1, val2, val3;    alGetListener3i (val_int (param), &val1, &val2, &val3);    value result = alloc_array (3);    val_array_set_i (result, 0, alloc_int (val1));    val_array_set_i (result, 1, alloc_int (val2));    val_array_set_i (result, 2, alloc_int (val3));    return result;}

value lime_al_get_source3f (value source, value param) {    ALfloat val1, val2, val3;    alGetBuffer3f (val_int (source), val_int (param), &val1, &val2, &val3);    value result = alloc_array (3);    val_array_set_i (result, 0, alloc_float (val1));    val_array_set_i (result, 1, alloc_float (val2));    val_array_set_i (result, 2, alloc_float (val3));    return result;}

value lime_al_get_source3i (value source, value param) {    ALint val1, val2, val3;    alGetSource3i (val_int (source), val_int (param), &val1, &val2, &val3);    value result = alloc_array (3);    val_array_set_i (result, 1, alloc_int (val1));    val_array_set_i (result, 2, alloc_int (val2));    val_array_set_i (result, 3, alloc_int (val3));    return result;}

/**	socket_poll_prepare : 'poll -> read:'socket array -> write:'socket array -> int array array	<doc>	Prepare a poll for scanning events on sets of sockets.	</doc>**/static value socket_poll_prepare( value pdata, value rsocks, value wsocks ) {	polldata *p;	int i,len;	val_check(rsocks,array);	val_check(wsocks,array);	val_check_kind(pdata,k_poll);	p = val_poll(pdata);	len = val_array_size(rsocks);	if( len + val_array_size(wsocks) > p->max )		val_throw(alloc_string("Too many sockets in poll"));#	ifdef NEKO_WINDOWS	for(i=0;i<len;i++) {		value s = val_array_i(rsocks,i);		p->fdr->fd_array[i] = val_sock(s);	}	p->fdr->fd_count = len;	len = val_array_size(wsocks);	for(i=0;i<len;i++) {		value s = val_array_i(wsocks,i);		p->fdw->fd_array[i] = val_sock(s);	}	p->fdw->fd_count = len;#	else	for(i=0;i<len;i++) {		value s = val_array_i(rsocks,i);		p->fds[i].fd = val_sock(s);		p->fds[i].events = POLLIN;		p->fds[i].revents = 0;	}	p->rcount = len;	len = val_array_size(wsocks);	for(i=0;i<len;i++) {		int k = i + p->rcount;		value s = val_array_i(wsocks,i);		p->fds[k].fd = val_sock(s);		p->fds[k].events = POLLOUT;		p->fds[k].revents = 0;	}	p->wcount = len;#	endif	{		value a = alloc_array(2);		val_array_set_i(a,0, p->ridx);		val_array_set_i(a,1, p->widx);		return a;	}}

/**	socket_poll_events : 'poll -> timeout:float -> void	<doc>	Update the read/write flags arrays that were created with [socket_poll_prepare].	</doc>**/static value socket_poll_events( value pdata, value timeout ) {	polldata *p;#	ifdef NEKO_WINDOWS	unsigned int i;	int k = 0;	struct timeval t;	val_check_kind(pdata,k_poll);	p = val_poll(pdata);	memcpy(p->outr,p->fdr,FDSIZE(p->fdr->fd_count));	memcpy(p->outw,p->fdw,FDSIZE(p->fdw->fd_count));	val_check(timeout,number);	init_timeval(val_number(timeout),&t);	gc_enter_blocking();	if( p->fdr->fd_count + p->fdw->fd_count != 0 && select(0,p->outr,p->outw,NULL,&t) == SOCKET_ERROR )	{		gc_exit_blocking();		return alloc_null();	}	gc_exit_blocking();	k = 0;	for(i=0;i<p->fdr->fd_count;i++)		if( FD_ISSET(p->fdr->fd_array[i],p->outr) )			val_array_set_i(p->ridx,k++,alloc_int(i));	val_array_set_i(p->ridx,k,alloc_int(-1));	k = 0;	for(i=0;i<p->fdw->fd_count;i++)		if( FD_ISSET(p->fdw->fd_array[i],p->outw) )			val_array_set_i(p->widx,k++, alloc_int(i));	val_array_set_i(p->widx,k,alloc_int(-1));#else	int i,k;	int tot;	val_check_kind(pdata,k_poll);	val_check(timeout,number);	p = val_poll(pdata);	tot = p->rcount + p->wcount;	gc_enter_blocking();	POSIX_LABEL(poll_events_again);	if( poll(p->fds,tot,(int)(val_number(timeout) * 1000)) < 0 ) {		HANDLE_EINTR(poll_events_again);		gc_exit_blocking();		return alloc_null();	}	gc_exit_blocking();	k = 0;	for(i=0;i<p->rcount;i++)		if( p->fds[i].revents & (POLLIN|POLLHUP) )			val_array_set_i(p->ridx,k++,alloc_int(i));	val_array_set_i(p->ridx,k, alloc_int(-1));	k = 0;	for(;i<tot;i++)		if( p->fds[i].revents & (POLLOUT|POLLHUP) )			val_array_set_i(p->widx,k++, alloc_int(i - p->rcount));	val_array_set_i(p->widx,k, alloc_int(-1));#endif	return val_null;}

value rtmidi_in_getmessage(value obj) {  RtMidiIn *midiin = (RtMidiIn *)(intptr_t)val_float(obj);  std::vector<unsigned char> message;  double stamp = midiin->getMessage(&message);  // ignore stamp for now  value ret = alloc_array(message.size());  for (int i = 0; i < message.size(); ++i) {    val_array_set_i(ret, i, alloc_int(message[i]));  }  return ret;}

static value dialogs_open_file( value title, value msg, value initialdir, value mask,value multi) {	value result = val_null;	struct ARG_FILEFILTERS filters = {0,0,0};	struct RES_STRINGLIST files;	val_check(title,string);	val_check(msg,string);	val_check(multi,bool);	val_check(initialdir, string);		if (val_is_object(mask)) {		value count = val_field(mask,val_id("count"));		value descriptions = val_field(mask,val_id("descriptions"));		value extensions = val_field(mask,val_id("extensions"));		val_check(count,int);		val_check(descriptions,array);		val_check(extensions,array);		filters.count = val_int(count);		if (filters.count) {			long i = filters.count;			filters.descriptions = (const char**) malloc(i*sizeof(char*));			filters.extensions = (const char**) malloc(i*sizeof(char*));			while(i) {				i--;				filters.descriptions[i] = val_string(val_array_i(descriptions,i));				filters.extensions[i] = val_string(val_array_i(extensions,i));			}		}	}		systools_dialogs_open_file(val_string(title),val_string(msg),val_string(initialdir),filters.count? &filters : NULL ,val_bool(multi) ,&files);	if (files.count) {		result = alloc_array(files.count);		while(files.count) {			files.count--;			val_array_set_i(result, files.count, alloc_string(files.strings[files.count]));			free(files.strings[files.count]);		}		free(files.strings);	}	// clean up allocated mem. for filters:	if (val_is_object(mask)) {		free(filters.descriptions);		free(filters.extensions);	}				return result;}

value hxfcgi_get_all_headers(value hreq) {	val_check_kind(hreq,hxRequest);		hxfcgi::BasicData d;	list<string> header = d.getAllHeaders();	list<string>::iterator iter;	value ret = alloc_array(header.size());	int c = 0;	for (iter = header.begin();iter != header.end(); iter++,c++) {		val_array_set_i(ret,c,alloc_string((*iter).c_str()));	}	return ret;}

void _rtmidi_in_callback(double deltatime,                         std::vector<unsigned char> *message,                         void *userData) {  int top = 0;  gc_set_top_of_stack(&top, true);  value ret = alloc_array(message->size());  for (int i = 0; i < message->size(); ++i) {    val_array_set_i(ret, i, alloc_int((*message)[i]));  }  val_call1(callback_root->get(), ret);  gc_set_top_of_stack(0,true);}

/**	socket_select : read : 'socket array -> write : 'socket array -> others : 'socket array -> timeout:number? -> 'socket array array	<doc>Perform the [select] operation. Timeout is in seconds or [null] if infinite</doc>**/static value socket_select( value rs, value ws, value es, value timeout ) {	struct timeval tval;	struct timeval *tt;	SOCKET n = 0;	fd_set rx, wx, ex;	fd_set *ra, *wa, *ea;	value r;	POSIX_LABEL(select_again);	ra = make_socket_array(rs,&rx,&n);	wa = make_socket_array(ws,&wx,&n);	ea = make_socket_array(es,&ex,&n);	if( ra == &INVALID || wa == &INVALID || ea == &INVALID )	{		val_throw( alloc_string("No valid sockets") );		return alloc_null();	}	if( val_is_null(timeout) )		tt = NULL;	else {		val_check(timeout,number);		tt = &tval;		init_timeval(val_number(timeout),tt);	}	gc_enter_blocking();	if( select((int)(n+1),ra,wa,ea,tt) == SOCKET_ERROR ) {		HANDLE_EINTR(select_again);		gc_exit_blocking();		char buf[100];		sprintf(buf,"Select error %d", errno );		val_throw( alloc_string(buf) );	}	gc_exit_blocking();	r = alloc_array(3);	val_array_set_i(r,0,make_array_result(rs,ra));	val_array_set_i(r,1,make_array_result(ws,wa));	val_array_set_i(r,2,make_array_result(es,ea));	return r;}

// DECL: void getCorners(Vector3* corners) const;void hx_Frustum_getCorners(value thisObj, value corners){    Frustum *_thisObj;    ValueToObject(thisObj, _thisObj);    Vector3 points[8];    _thisObj->getCorners(points);    value _corners = alloc_array(8);    for (int index = 0; index < 8; index++)        val_array_set_i(_corners, index, ObjectToValue(new Vector3(points[index])));    SetOutParameterValue(corners, _corners);}

/**	socket_poll : 'socket array -> 'poll -> timeout:float -> 'socket array	<doc>	Perform a polling for data available over a given set of sockets. This is similar to [socket_select]	except that [socket_select] is limited to a given number of simultaneous sockets to check.	</doc>**/static value socket_poll( value socks, value pdata, value timeout ) {	polldata *p;	value a;	int i, rcount = 0;	if( val_is_null( socket_poll_prepare(pdata,socks,alloc_array(0))) )		return alloc_null();	socket_poll_events(pdata,timeout);	p = val_poll(pdata);	while( val_int(val_array_i(p->ridx,rcount)) != -1 )		rcount++;	a = alloc_array(rcount);	for(i=0;i<rcount;i++)		val_array_set_i(a,i, val_array_i(socks,val_int(val_array_i(p->ridx,i))));	return a;}

static value make_array_result( value a, fd_set *tmp ) {	value r;	int i, len;	int pos = 0;	if( tmp == NULL )		return val_null;	len = val_array_size(a);	r = alloc_array(len);	for(i=0;i<len;i++) {		value s = val_array_i(a,i);		if( FD_ISSET(val_sock(s),tmp) )			val_array_set_i(r,pos++,s);	}	val_array_set_size(r,pos);	return r;}

	value lime_al_gen_buffers (int n) {				ALuint* buffers = new ALuint[n];		alGenBuffers (n, buffers);				value result = alloc_array (n);				for (int i = 0; i < n; i++) {						val_array_set_i (result, i, alloc_int (buffers[i]));					}				delete [] buffers;		return result;			}

	value lime_al_gen_sources (int n) {				ALuint* sources = new ALuint[n];		alGenSources (n, sources);				value result = alloc_array (n);				for (int i = 0; i < n; i++) {						val_array_set_i (result, i, alloc_int (sources[i]));					}				delete [] sources;		return result;			}

	value lime_al_get_booleanv (int param, int count) {				ALboolean* values = new ALboolean[count];		alGetBooleanv (param, values);				value result = alloc_array (count);				for (int i = 0; i < count; i++) {						val_array_set_i (result, i, alloc_bool (values[i]));					}				delete [] values;		return result;			}

	value lime_al_get_bufferfv (int buffer, int param, int count) {				ALfloat* values = new ALfloat[count];		alGetBufferfv (buffer, param, values);				value result = alloc_array (count);				for (int i = 0; i < count; ++i) {						val_array_set_i (result, i, alloc_float (values[i]));					}				delete [] values;		return result;			}

	value lime_al_get_listenerfv (int param, int count) {				ALfloat* values = new ALfloat[count];		alGetListenerfv (param, values);				value result = alloc_array (count);				for (int i = 0; i < count; i++) {						val_array_set_i (result, i, alloc_float (values[i]));					}				delete [] values;		return result;			}

	value lime_al_get_sourceiv (int source, int param, int count) {				ALint* values = new ALint[count];		alGetSourceiv (source, param, values);				value result = alloc_array (count);				for (int i = 0; i < count; i++) {						val_array_set_i (result, i, alloc_int (values[i]));					}				delete [] values;		return result;			}

	value lime_al_source_unqueue_buffers (int source, int nb) {				ALuint* buffers = new ALuint[nb];		alSourceUnqueueBuffers (source, nb, buffers);				value result = alloc_array (nb);				for (int i = 0; i < nb; i++) {						val_array_set_i (result, i, alloc_int (buffers[i]));					}				delete [] buffers;		return result;			}