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

static void report( neko_vm *vm, value exc, int isexc ) {	int i;	buffer b = alloc_buffer(NULL);	value st = neko_exc_stack(vm);	for(i=0;i<val_array_size(st);i++) {		value s = val_array_ptr(st)[i];		buffer_append(b,"Called from ");		if( val_is_null(s) )			buffer_append(b,"a C function");		else if( val_is_string(s) ) {			buffer_append(b,val_string(s));			buffer_append(b," (no debug available)");		} else if( val_is_array(s) && val_array_size(s) == 2 && val_is_string(val_array_ptr(s)[0]) && val_is_int(val_array_ptr(s)[1]) ) {			val_buffer(b,val_array_ptr(s)[0]);			buffer_append(b," line ");			val_buffer(b,val_array_ptr(s)[1]);		} else			val_buffer(b,s);		buffer_append_char(b,'/n');	}	if( isexc )		buffer_append(b,"Uncaught exception - ");	val_buffer(b,exc);#	ifdef NEKO_STANDALONE	neko_standalone_error(val_string(buffer_to_string(b)));#	else	fprintf(stderr,"%s/n",val_string(buffer_to_string(b)));#	endif}

/**	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,val_array_size(rs),&rx,&n);	wa = make_socket_array(ws,val_array_size(ws),&wx,&n);	ea = make_socket_array(es,val_array_size(es),&ex,&n);	if( ra == &INVALID || wa == &INVALID || ea == &INVALID )		neko_error();	if( val_is_null(timeout) )		tt = NULL;	else {		val_check(timeout,number);		tt = &tval;		init_timeval(val_number(timeout),tt);	}	if( select((int)(n+1),ra,wa,ea,tt) == SOCKET_ERROR ) {		HANDLE_EINTR(select_again);		neko_error();	}	r = alloc_array(3);	val_array_ptr(r)[0] = make_array_result(rs,ra);	val_array_ptr(r)[1] = make_array_result(ws,wa);	val_array_ptr(r)[2] = make_array_result(es,ea);	return r;}

/**	$acopy : array -> array	<doc>Make a copy of an array</doc>**/static value builtin_acopy( value a ) {	int i;	value a2;	val_check(a,array);	a2 = alloc_array(val_array_size(a));	for(i=0;i<val_array_size(a);i++)		val_array_ptr(a2)[i] = val_array_ptr(a)[i];	return a2;}

/**	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_ptr(rsocks)[i];		val_check_kind(s,k_socket);		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_ptr(wsocks)[i];		val_check_kind(s,k_socket);		p->fdw->fd_array[i] = val_sock(s);	}	p->fdw->fd_count = len;#	else	for(i=0;i<len;i++) {		value s = val_array_ptr(rsocks)[i];		val_check_kind(s,k_socket);		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_ptr(wsocks)[i];		val_check_kind(s,k_socket);		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_ptr(a)[0] = p->ridx;		val_array_ptr(a)[1] = p->widx;		return a;	}}

/**	same_closure : any -> any -> bool	<doc>	Compare two functions by checking that they refer to the same implementation and that their environments contains physically equal values.	</doc>**/static value same_closure( value _f1, value _f2 ) {	vfunction *f1 = (vfunction*)_f1;	vfunction *f2 = (vfunction*)_f2;	int i;	if( !val_is_function(f1) || !val_is_function(f2) )		return val_false;	if( f1 == f2 )		return val_true;	if( f1->nargs != f2->nargs || f1->addr != f2->addr || f1->module != f2->module || val_array_size(f1->env) != val_array_size(f2->env) )		return val_false;	for(i=0;i<val_array_size(f1->env);i++)		if( val_array_ptr(f1->env)[i] != val_array_ptr(f2->env)[i] )			return val_false;	return val_true;}

// Array access - genericint api_val_array_size(value  arg1){	if (val_is_array(arg1))	   return val_array_size(arg1);	value l = val_field(arg1,length_id);	return val_int(l);}

/**	$objcall : o:any -> f:int -> args:array -> any	<doc>Call the field [f] of [o] with [args] and return the value or [null] is [o] is not an object</doc>**/static value builtin_objcall( value o, value f, value args ) {	if( !val_is_object(o) )		return val_null; // keep dot-access semantics	val_check(f,int);	val_check(args,array);	return val_ocallN(o,val_int(f),val_array_ptr(args),val_array_size(args));}

	value lime_alc_create_context (value device, value attrlist) {				ALCdevice* alcDevice = (ALCdevice*)val_data (device);				ALCint* list = NULL;				if (val_is_null (attrlist) == false) {						int size = val_array_size (attrlist);			list = new ALCint[size];						for (int i = 0; i < size; ++i) {				list[i] = (ALCint)val_int( val_array_i (attrlist, i) );			}					}				ALCcontext* alcContext = alcCreateContext (alcDevice, list);				if (list != NULL) {			delete[] list;		}				return CFFIPointer (alcContext);			}

EXTERN value neko_select_file( value path, const char *file, const char *ext ) {	struct stat s;	value ff;	buffer b = alloc_buffer(file);	buffer_append(b,ext);	ff = buffer_to_string(b);	if( stat(val_string(ff),&s) == 0 ) {		char *p = strchr(file,'/');		if( p == NULL )			p = strchr(file,'//');		if( p != NULL )			return ff;		b = alloc_buffer("./");		buffer_append(b,file);		buffer_append(b,ext);		return buffer_to_string(b);	}	while( val_is_array(path) && val_array_size(path) == 2 ) {		value p = val_array_ptr(path)[0];		buffer b = alloc_buffer(NULL);		path = val_array_ptr(path)[1];		val_buffer(b,p);		val_buffer(b,ff);		p = buffer_to_string(b);		if( stat(val_string(p),&s) == 0 )			return p;	}	return ff;}

static value apply1( value p1 ) {	value env = NEKO_VM()->env;	value *a = val_array_ptr(env) + 1;	int n = val_array_size(env) - 1;	a[n-1] = p1;	return val_callN(a[-1],a,n);}

static value apply3( value p1, value p2, value p3 ) {	value env = NEKO_VM()->env;	value *a = val_array_ptr(env) + 1;	int n = val_array_size(env) - 1;	a[n-3] = p1;	a[n-2] = p2;	a[n-1] = p3;	return val_callN(a[-1],a,n);}

static void report( neko_vm *vm, value exc ) {#if OSX	CFStringRef title = CFSTR("Uncaught exception");	CFStringRef message;#endif	int i = 0;	buffer b = alloc_buffer(NULL);	value st = neko_exc_stack(vm);	if( val_array_size(st) > 20 ) {		i = val_array_size(st) - 20;		buffer_append(b,".../n");	}	for(i;i<val_array_size(st);i++) {		value s = val_array_ptr(st)[i];		if( val_is_null(s) )			buffer_append(b,"Called from a C function/n");		else if( val_is_string(s) ) {			buffer_append(b,"Called from ");			buffer_append(b,val_string(s));			buffer_append(b," (no debug available)/n");		} else if( val_is_array(s) && val_array_size(s) == 2 && val_is_string(val_array_ptr(s)[0]) && val_is_int(val_array_ptr(s)[1]) ) {			buffer_append(b,"Called from ");			buffer_append(b,val_string(val_array_ptr(s)[0]));			buffer_append(b," line ");			val_buffer(b,val_array_ptr(s)[1]);			buffer_append(b,"/n");		} else {			buffer_append(b,"Called from ");			val_buffer(b,s);			buffer_append(b,"/n");		}	}	val_buffer(b,exc);#if _WIN32	MessageBox(NULL,val_string(buffer_to_string(b)),"Uncaught exception",MB_OK | MB_ICONERROR);#elif OSX	message = CFStringCreateWithCString(NULL,val_string(buffer_to_string(b)), kCFStringEncodingUTF8);	CFUserNotificationDisplayNotice(0,0,NULL,NULL,NULL,title,message,NULL);#elif LINUX	fprintf(stderr,"Uncaught Exception: %s/n",val_string(buffer_to_string(b)));#endif}

	void lime_gamepad_add_mappings (value mappings) {				int length = val_array_size (mappings);				for (int i = 0; i < length; i++) {						Gamepad::AddMapping (val_string (val_array_i (mappings, i)));					}			}

/**	$call : f:function -> this:any -> args:array -> any	<doc>Call [f] with [this] context and [args] arguments</doc>**/static value builtin_call( value f, value ctx, value args ) {	value old;	value ret;	neko_vm *vm;	val_check(args,array);	vm = NEKO_VM();	old = vm->vthis;	vm->vthis = ctx;	ret = val_callN(f,val_array_ptr(args),val_array_size(args));	vm->vthis = old;	return ret;}

value rtmidi_out_sendmessage(value obj, value msg) {  RtMidiOut *midiout = (RtMidiOut *)(intptr_t)val_float(obj);  std::vector<unsigned char> message;  int size = val_array_size(msg);  for (int i = 0; i < size; ++i) {    message.push_back(val_int(val_array_i(msg, i)));  }  midiout->sendMessage(&message);  return alloc_null();}

/**	$aconcat : array array -> array	<doc>	Build a single array from several ones.	</doc>**/static value builtin_aconcat( value arrs ) {	int tot = 0;	int len;	int i;	value all;	val_check(arrs,array);	len = val_array_size(arrs);	for(i=0;i<len;i++) {		value a = val_array_ptr(arrs)[i];		val_check(a,array);		tot += val_array_size(a);	}	all = alloc_array(tot);	tot = 0;	for(i=0;i<len;i++) {		value a = val_array_ptr(arrs)[i];		int j, max = val_array_size(a);		for(j=0;j<max;j++)			val_array_ptr(all)[tot++] = val_array_ptr(a)[j];	}	return all;}

/**	$ablit : dst:array -> dst_pos:int -> src:array -> src_pos:int -> len:int -> void	<doc>	Copy [len] elements from [src_pos] of [src] to [dst_pos] of [dst].	An error occurs if out of arrays bounds.	</doc>**/static value builtin_ablit( value dst, value dp, value src, value sp, value l ) {	int dpp, spp, ll;	val_check(dst,array);	val_check(dp,int);	val_check(src,array);	val_check(sp,int);	val_check(l,int);	dpp = val_int(dp);	spp = val_int(sp);	ll = val_int(l);	if( dpp < 0 || spp < 0 || ll < 0 || dpp + ll < 0 || spp + ll  < 0 || dpp + ll > val_array_size(dst) || spp + ll > val_array_size(src) )		neko_error();	memmove(val_array_ptr(dst)+dpp,val_array_ptr(src)+spp,ll * sizeof(value));	return val_null;}

static value neko_flush_stack( int_val *cspup, int_val *csp, value old ) {	int ncalls = (int)((cspup - csp) / 4);	value stack_trace = alloc_array(ncalls + ((old == NULL)?0:val_array_size(old)));	value *st = val_array_ptr(stack_trace);	neko_module *m;	while( csp != cspup ) {		m = (neko_module*)csp[4];		if( m ) {			if( m->dbgidxs ) {				int ppc = (int)((((int_val**)csp)[1]-2) - m->code);				int idx = m->dbgidxs[ppc>>5].base + bitcount(m->dbgidxs[ppc>>5].bits >> (31 - (ppc & 31)));				*st = val_array_ptr(m->dbgtbl)[idx];			} else				*st = m->name;		} else

/**	$asub : array -> p:int -> l:int -> array	<doc>	Return [l] elements starting at position [p] of an array.	An error occurs if out of array bounds.	</doc>**/static value builtin_asub( value a, value p, value l ) {	value a2;	int i;	int pp, ll;	val_check(a,array);	val_check(p,int);	val_check(l,int);	pp = val_int(p);	ll = val_int(l);	if( pp < 0 || ll < 0 || pp+ll < 0 || pp+ll > val_array_size(a) )		neko_error();	a2 = alloc_array(ll);	for(i=0;i<ll;i++)		val_array_ptr(a2)[i] = val_array_ptr(a)[pp+i];	return a2;}

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;}

	void lime_cairo_set_dash (value handle, value dash) {				int length = val_array_size (dash);				double* dashPattern = new double[length];				for (int i = 0; i < length; i++) {						dashPattern[i] = val_number (val_array_i (dash, i));					}				cairo_set_dash ((cairo_t*)val_data (handle), dashPattern, length, 0);		delete dashPattern;			}

	void lime_al_source_pausev (int n, value sources) {				if (val_is_null (sources) == false) {						int size = val_array_size (sources);			ALuint* data = new ALuint[size];						for (int i = 0; i < size; ++i) {								data[i] = (ALuint)val_int( val_array_i (sources, i) );							}						alSourcePausev (n, data);						delete[] data;					}	}

	void lime_al_delete_buffers (int n, value buffers) {				if (val_is_null (buffers) == false) {						int size = val_array_size (buffers);			ALuint* data = new ALuint[size];						for (int i = 0; i < size; ++i) {								data[i] = (ALuint)val_int( val_array_i (buffers, i) );							}						alDeleteBuffers (n, data);						delete[] data;					}			}

	void lime_al_listenerfv (int param, value values) {				if (val_is_null (values) == false) {						int size = val_array_size (values);			ALfloat *data = new ALfloat[size];						for (int i = 0; i < size; ++i) {								data[i] = (ALfloat)val_float( val_array_i (values, i) );							}						alListenerfv(param, data);						delete[] data;					}			}

	void lime_al_source_queue_buffers (int source, int nb, value buffers) {				if (val_is_null (buffers) == false) {						int size = val_array_size (buffers);			ALuint* data = new ALuint[size];						for (int i = 0; i < size; ++i) {								data[i] = (ALuint)val_int( val_array_i (buffers, i) );							}						alSourceQueueBuffers (source, nb, data);						delete[] data;					}			}

	void lime_al_sourceiv (int source, int param, value values) {				if (val_is_null (values) == false) {						int size = val_array_size (values);			ALint* data = new ALint[size];						for (int i = 0; i < size; ++i) {								data[i] = (ALint)val_int( val_array_i (values, i) );							}						alSourceiv (source, param, data);						delete[] data;					}			}

static fd_set *make_socket_array( value a, fd_set *tmp, SOCKET *n ) {	int i, len;	SOCKET sock;	FD_ZERO(tmp);	if( val_is_null(a) )		return tmp;	if( !val_is_array(a) )		return &INVALID;	len = val_array_size(a);	if( len > FD_SETSIZE )		val_throw(alloc_string("Too many sockets in select"));	for(i=0;i<len;i++) {		value s = val_array_i(a,i);                // make sure it is a socket...		sock = val_sock(s);		if( sock > *n )			*n = sock;		FD_SET(sock,tmp);	}	return tmp;}

static void make_array_result_inplace(value a, fd_set *tmp){    if (tmp == NULL) {        val_array_set_size(a, 0);        return;    }    int len = val_array_size(a);    value *results = (value *) malloc(sizeof(value) * len);    int result_len = 0;    for (int i = 0; i < len; i++) {        value s = val_array_i(a, i);        if (FD_ISSET(val_sock(s), tmp)) {            results[result_len++] = s;        }    }    val_array_set_size(a, result_len);    for (int i = 0; i < result_len; i++) {        val_array_set_i(a, i, results[i]);    }    free(results);}

static value closure_callback( value *args, int nargs ) {	value env = NEKO_VM()->env;	int cargs = val_array_size(env) - 2;	value *a = val_array_ptr(env);	value f = a[0];	value o = a[1];	int fargs = val_fun_nargs(f);	int i;	if( fargs != cargs + nargs && fargs != VAR_ARGS )		return val_null;	if( nargs == 0 )		a = val_array_ptr(env) + 2;	else if( cargs == 0 )		a = args;	else {		a = (value*)alloc(sizeof(value)*(nargs+cargs));		for(i=0;i<cargs;i++)			a[i] = val_array_ptr(env)[i+2];		for(i=0;i<nargs;i++)			a[i+cargs] = args[i];	}	return val_callEx(o,f,a,nargs+cargs,NULL);}

void NekoCodeChunk::neko_dump(std::string const & indent) const {	for (const_iterator it = begin();		 it != end();		 ++it)		{			std::cout << indent << it->first << ": ";			print_neko_instruction((OPCODE) it->second.first, it->second.second, parameter_table[it->second.first]);			std::cout << "; // ";			{				int ppc = (int)((int_val *)it->first - m->code);				int idx = m->dbgidxs[ppc>>5].base + bitcount(m->dbgidxs[ppc>>5].bits >> (31 - (ppc & 31)));				value s = val_array_ptr(m->dbgtbl)[idx];				if( val_is_string(s) )					printf("%s",val_string(s));				else if( val_is_array(s) && val_array_size(s) == 2 && val_is_string(val_array_ptr(s)[0]) && val_is_int(val_array_ptr(s)[1]) )					printf("file %s line %d",val_string(val_array_ptr(s)[0]),val_int(val_array_ptr(s)[1]));				else					printf("???");			}			std::cout << std::endl;		}}