Ejemplo n.º 1
0
int
enet_socket_send (ENetSocket socket,
                  const ENetAddress * address,
                  const ENetBuffer * buffers,
                  size_t bufferCount)
{
    ENetAddress address_clone;
    int address_length = enet_address_get_size (address);
    DWORD sentLength;

    if (address != NULL)
    {
        memcopy (& address_clone, address, address_length);

        address_clone.port = ENET_HOST_TO_NET_16 (address -> port);
    }

    if (WSASendTo (socket,
                   (LPWSABUF) buffers,
                   (DWORD) bufferCount,
                   & sentLength,
                   0,
                   address != NULL ? (struct sockaddr *) & address_clone : NULL,
                   address != NULL ? address_length : 0,
                   NULL,
                   NULL) == SOCKET_ERROR)
    {
       if (WSAGetLastError () == WSAEWOULDBLOCK)
         return 0;

       return -1;
    }

    return (int) sentLength;
}
Ejemplo n.º 2
0
void SendData(ArgStruct *p)
{
   int nbytes = p->bufflen, nb, mb;
   char *src = p->s_ptr, *dest = p->r_ptr;

#if defined( USE_PIPE )          /* Push the data thru a pipe */

   while( nbytes > 0 ) {

         /* non-blocking, so write as much as I can (~1 page) */

      nb = write(p->prot.fd[1], src, nbytes);

      mb = read( p->prot.fd[0], dest, nb);

      if( nb <= 0 || mb != nb ) {
         fprintf(stderr,"Pipe transfer was unsuccessful (%d/%d %d/%d)\n",
                 mb, nb, nbytes, p->bufflen);
      }
      src += nb;
      dest += nb;
      nbytes -= nb;
   }
#else
   memcopy(dest, src, nbytes);
#endif
}
Ejemplo n.º 3
0
dirent_t *readdir(inode_t *node, uint32_t offset)
{
	CALLOCP(message, vfsm);
	message->m.msg_type = VFSM_READDIR;
	memcopy((uint8_t *)&message->readdir.node, (uint8_t *)node, sizeof(inode_t));
	message->readdir.num = offset;
	
	send2(VFS_PID, message);
	
	vfsm *reply = waitmsg(VFS_PID,0);
	memcopy((uint8_t *)&dirent, (uint8_t *)&reply->readdir_reply.dirent, sizeof(dirent_t));
	free(message);
	free(reply);
	
	return &dirent;
}
Ejemplo n.º 4
0
/*
 * Cette fonction initialise la GDT apres que le kernel soit charge 
 * en memoire. Une GDT est deja operationnelle, mais c'est celle qui
 * a ete initialisee par le secteur de boot et qui ne correspond
 * pas forcement a celle que l'on souhaite pour bosokernel.
 */
void init_gdt(void) {
	struct gdtdesc code, data, stack;

	/* initialisation des descripteurs de segment */
	init_code_desc(0x0, 0xFFFFF, &code);
	init_data_desc(0x0, 0xFFFFF, &data);
	init_gdt_desc(0, 0x10, 0x97, 0x0D, &stack);
	add_gdt_desc(code);
	add_gdt_desc(data);
	add_gdt_desc(stack);

	/* initialisation de la structure pour GDTR */
	kgdtr.limite = GDTSIZE*8;
	kgdtr.base = GDTBASE;

	/* recopie de la GDT a son adresse */	
	memcopy(kgdt, kgdtr.base, kgdtr.limite);
	
	/* chargement du registre GDTR */
	asm("lgdtl (kgdtr)");

	/* initialisation des segments */
	asm("	movw $0x10,%ax	\n \
		movw %ax, %ds	\n \
		movw %ax, %es	\n \
		movw %ax, %fs	\n \
		movw %ax, %gs	\n \
		movw $0x18,%ax	\n \
		movw %ax, %ss	\n \
		movl $0x1FFFF,%esp	\n \
		nop	\n \
		nop	\n \
		ljmp $0x08,$next	\n \
		next:	\n");
}
Ejemplo n.º 5
0
int	file_buff_write(void * buf,Inode* p_inode,int offset,int count)
{
	// 1、确定操作位置
	if(offset < 0 || offset >= FILE_MAX_SIZE)
	{
		printk("write pos out of file offset : %x\n",offset);
		return	-1;		// 位置超出范围
	}
	// 2、写入。在缓冲区中操作,如果文件不在缓冲区内,则先读入缓冲区
	int	buff_offset	= offset % BUFF_SIZE;	// 确定缓冲区中的操作位置
	int	buf_offset	= 0;			// 待写数据中的偏移
	int	cnt		= 0;			// 已写入字节数
	while(count > 0)
	{
		// 1、搜索待写文件是否在缓冲区,如果不在就将其读入缓冲区
		BUFF_HEAD*	p_bh	= scan_buff(p_inode,offset);
		if(p_bh == 0)
		{
			p_bh	= get_buff(p_inode,offset);	// 申请缓冲区
			if(p_bh == 0)	return	-1;	// 缓冲区用完
			read_buff(p_bh);			// 文件读入缓冲区
		}
		// 2、此时待写文件已经在缓冲区,在缓冲区中写入内容
		void*	buff_base		= p_bh->buff_base;		// 缓冲区地址
		int	buff_remin	= BUFF_SIZE - buff_offset;	// 缓冲区剩余字节数
		
		if(buff_remin >= count)		// 当前缓冲区能容纳所有剩余数据
		{
			memcopy(buff_base + buff_offset,buf + buf_offset,count);
			cnt += count;		// 剩余数据全部写入,然后返回
			p_bh->dirty	= 1;	// 文件缓冲“脏”标志
			return	cnt;
		}
		else				// 当前缓冲区不能容纳所有剩余数据
		{
			memcopy(buff_base + buff_offset,buf + buf_offset,buff_remin);
			buff_offset  = 0;		// 写满当前缓冲区后循环写下一个缓冲区
			buf_offset += buff_remin;
			count	 -= buff_remin;
			cnt	 += buff_remin;
			offset	 += buff_remin;
			p_bh->dirty	= 1;	// 文件缓冲“脏”标志
		}
	}
	return	0;	// 不可能到达这里
}
Ejemplo n.º 6
0
int	file_buff_read(void * buf,Inode* p_inode,int offset,int count)
{
	// 1、确定操作位置
	if(offset < 0 || offset >= FILE_MAX_SIZE)
	{
		printk("read pos out of file offset : %x\n",offset);
		return	-1;		// 位置超出范围
	}
	// 2、读取。在缓冲区中操作,如果文件不在缓冲区内,则先读入缓冲区
	int	buff_offset	= offset % BUFF_SIZE;	// 确定缓冲区中的操作位置
	int	buf_offset	= 0;			// 待读数据中的偏移
	int	cnt		= 0;			// 已读取字节数
	while(count > 0)
	{
		// 1、搜索待读文件是否在缓冲区,如果不在就将其读入缓冲区
		BUFF_HEAD*	p_bh	= scan_buff(p_inode,offset);
		if(p_bh == 0)
		{
			p_bh	= get_buff(p_inode,offset);	// 申请缓冲区
			if(p_bh == 0)	return	-1;	// 缓冲区用完
			read_buff(p_bh);			// 文件读入缓冲区
			//printk("111 i_num : %d  buff_base:%x    offset: %d \n",p_bh->p_inode->i_num,p_bh->buff_base,p_bh->offset);
		}
		// 2、此时待读文件已经在缓冲区,在缓冲区中读取内容
		void*	buff_base		= p_bh->buff_base;		// 缓冲区地址
		int	buff_remin	= BUFF_SIZE - buff_offset;	// 缓冲区剩余字节数
		
		if(buff_remin >= count)		// 当前缓冲区能容纳所有剩余数据
		{
			memcopy(buf + buf_offset,buff_base + buff_offset,count);
			cnt += count;		// 剩余数据全部读取,然后返回
			return	cnt;
		}
		else				// 当前缓冲区不能容纳所有剩余数据
		{
			memcopy(buf + buf_offset,buff_base + buff_offset,buff_remin);
			buff_offset  = 0;		// 读完当前缓冲区后循环读取下一个缓冲区
			buf_offset += buff_remin;
			count	 -= buff_remin;
			cnt	 += buff_remin;
			offset	 += buff_remin;
		}
	}
	return	0;	// 不可能到达这里
}
Ejemplo n.º 7
0
void RecvData(ArgStruct *p)
{
   int nbytes = p->bufflen;
   char *src = p->s_ptr, *dest = p->r_ptr;

   return;  /* Do nothing */

   memcopy(src, dest, nbytes);
}
Ejemplo n.º 8
0
void test_memcopy(
    Test * pTest)
{
    char *data1 = "Joshua";
    char *data2 = "Anna";
    char buffer[480] = "";
    char big_buffer[480] = "";
    size_t len = 0;

    len = memcopy(&buffer[0], &data1[0], 0, sizeof(data1), sizeof(buffer));
    ct_test(pTest, len == sizeof(data1));
    ct_test(pTest, memcmp(&buffer[0], &data1[0], len) == 0);
    len = memcopy(&buffer[0], &data2[0], len, sizeof(data2), sizeof(buffer));
    ct_test(pTest, len == sizeof(data2));
    len =
        memcopy(&buffer[0], &big_buffer[0], 1, sizeof(big_buffer),
        sizeof(buffer));
    ct_test(pTest, len == 0);
}
unsigned int ArchivedFile::read(void* dest, unsigned int bytes)
{
  bytes = (index + bytes) > size ? size - index : bytes;
  
  //if (bytes > 0)
  memcopy(dest, data + index, bytes);
  //memcpy(dest, data + index, bytes);
  index += bytes;
  
  return bytes;
}
Ejemplo n.º 10
0
void BusyWork(void) {
	char array[4096];
	int addr = (int)(&PrintLoggedOutMenu) & 0xfffff000;
	int i = 20;

	while (i--) {
		memcopy(array, (char *)addr, 4096);
		sort_n_sum(array, 4096);
	}

}
Ejemplo n.º 11
0
void chroot(inode_t *node)
{
	CALLOCP(message, vfsm);
	message->m.msg_type = VFSM_CHRD;
	memcopy((uint8_t *)&message->chrd.rd, (uint8_t *)node, sizeof(inode_t));

	send2(VFS_PID,message);
	free(waitmsg(VFS_PID,0));
	
	free(message);
}
Ejemplo n.º 12
0
int
enet_socket_bind (ENetSocket socket, const ENetAddress * address)
{
    const size_t length = enet_address_get_size (address);
    ENetAddress * clone;

    memcopy (& clone, address, length);
    clone -> port = ENET_HOST_TO_NET_16 (address -> port);

    return bind (socket, (struct sockaddr *) clone, length);
}
Ejemplo n.º 13
0
Archivo: memcopy.c Proyecto: pharic/c
int main() {
	int src[] = {1,2,3,4,5}, i;
	int n = sizeof(src) / sizeof(src[0]);
	int *dst = malloc(n*sizeof(src[0]));
	memcopy((void*)src,(void*)dst,sizeof(src));
	printf ("Destination is: ");
	for (i=0; i<n; i++) {
		printf ("%d ", dst[i]);
	}
	printf ("\n");
	free(dst);
	return 0;
}
Ejemplo n.º 14
0
stat_t *fstat(uint32_t filp)
{
	CALLOCP(message, vfsm);
	message->m.msg_type = VFSM_FSTAT;
	message->fstat.filp = filp;
	
	send2(VFS_PID, message);
	
	vfsm *reply = (vfsm *)waitmsg(VFS_PID,0);
	memcopy((uint8_t *)&stat, (uint8_t *)&reply->fstat_reply.node, sizeof(stat_t));
	free(message);
	free(reply);
	return &stat;
}
Ejemplo n.º 15
0
int
enet_address_set_host (ENetAddress * address, const char * name)
{
    struct addrinfo * result_box;
    int error_code;

    error_code = getaddrinfo(name, NULL, &hints, &result_box);
    if (error_code != 0) return error_code;
    if (result_box == NULL) return -1;

    memcopy(&address, result_box -> ai_addr, result_box -> ai_addrlen);
    address -> port = ENET_NET_TO_HOST_16 (address -> port);
    return error_code;
}
Ejemplo n.º 16
0
/*
 * Cette fonction initialise la IDT apres que le kernel soit charge 
 * en memoire. 
 */
void init_idt(void) {
	idtdesc desc;
	int i;

	/* initialisation des descripteurs systeme */
	for(i=0;i<IDTSIZE;i++) {
		init_idt_desc(default_int, 0x08, INTGATE, &desc);
		add_idt_desc(desc);
	}

	init_idt_desc(k_int0, 0x08, INTGATE, &kidt[0]);
	init_idt_desc(k_int1, 0x08, INTGATE, &kidt[1]);
	init_idt_desc(k_int2, 0x08, INTGATE, &kidt[2]);
	init_idt_desc(k_int3, 0x08, INTGATE, &kidt[3]);
	init_idt_desc(k_int4, 0x08, INTGATE, &kidt[4]);
	init_idt_desc(k_int5, 0x08, INTGATE, &kidt[5]);
	init_idt_desc(k_int6, 0x08, INTGATE, &kidt[6]);
	init_idt_desc(k_int7, 0x08, INTGATE, &kidt[7]);
	init_idt_desc(k_int8, 0x08, INTGATE, &kidt[8]);
	init_idt_desc(k_int9, 0x08, INTGATE, &kidt[9]);
	init_idt_desc(k_int10, 0x08, INTGATE, &kidt[10]);
	init_idt_desc(k_int11, 0x08, INTGATE, &kidt[11]);
	init_idt_desc(k_int12, 0x08, INTGATE, &kidt[12]);
	init_idt_desc(k_int13, 0x08, INTGATE, &kidt[13]);
	init_idt_desc(k_int14, 0x08, INTGATE, &kidt[14]);
	init_idt_desc(k_int15, 0x08, INTGATE, &kidt[15]);
	init_idt_desc(k_int16, 0x08, INTGATE, &kidt[16]);
	init_idt_desc(k_int17, 0x08, INTGATE, &kidt[17]);
	init_idt_desc(k_int18, 0x08, INTGATE, &kidt[18]);

	init_idt_desc(k_irq0, 0x08, INTGATE, &kidt[32]);
	init_idt_desc(k_irq1, 0x08, INTGATE, &kidt[33]);
	init_idt_desc(k_irq2, 0x08, INTGATE, &kidt[34]);
	init_idt_desc(k_irq3, 0x08, INTGATE, &kidt[35]);
	init_idt_desc(k_irq4, 0x08, INTGATE, &kidt[36]);
	init_idt_desc(k_irq5, 0x08, INTGATE, &kidt[37]);
	init_idt_desc(k_irq6, 0x08, INTGATE, &kidt[38]);
	init_idt_desc(k_irq7, 0x08, INTGATE, &kidt[39]);
	init_idt_desc(k_irq8, 0x08, INTGATE, &kidt[40]);

	/* initialisation de la structure pour IDTR */
	kidtr.limite = IDTSIZE*8;
	kidtr.base = IDTBASE;

	/* recopie de la IDT a son adresse */
	memcopy(kidt, kidtr.base, kidtr.limite);

	/* chargement du registre IDTR */
	asm("lidtl (kidtr)");
}
Ejemplo n.º 17
0
static Py_ssize_t _encodedir(char *dest, size_t destsize,
                             const char *src, Py_ssize_t len)
{
	enum dir_state state = DDEFAULT;
	Py_ssize_t i = 0, destlen = 0;

	while (i < len) {
		switch (state) {
		case DDOT:
			switch (src[i]) {
			case 'd':
			case 'i':
				state = DHGDI;
				charcopy(dest, &destlen, destsize, src[i++]);
				break;
			case 'h':
				state = DH;
				charcopy(dest, &destlen, destsize, src[i++]);
				break;
			default:
				state = DDEFAULT;
				break;
			}
			break;
		case DH:
			if (src[i] == 'g') {
				state = DHGDI;
				charcopy(dest, &destlen, destsize, src[i++]);
			}
			else state = DDEFAULT;
			break;
		case DHGDI:
			if (src[i] == '/') {
				memcopy(dest, &destlen, destsize, ".hg", 3);
				charcopy(dest, &destlen, destsize, src[i++]);
			}
			state = DDEFAULT;
			break;
		case DDEFAULT:
			if (src[i] == '.')
				state = DDOT;
			charcopy(dest, &destlen, destsize, src[i++]);
			break;
		}
	}

	return destlen;
}
void cMatrixStack::copyfrom(cMatrixStack *c)
{	if (c->levels!=levels)
		msg("MatrixStack Error",buildstr("Cannot copy a %i level Matrix Stack over a %i level Matrix Stack"));
	
	for (uintf i=0; i<levels; i++)
	{	level[i].parent = c->level[i].parent;
		level[i].pivot = c->level[i].pivot;
		level[i].rotx = c->level[i].rotx;
		level[i].roty = c->level[i].roty;
		level[i].rotz = c->level[i].rotz;
		float *dm = level[i].mtx;
		float *sm = c->level[i].mtx;
		memcopy(dm, sm, sizeof(Matrix));
		level[i].current = c->level[i].current;
	}
}
Ejemplo n.º 19
0
int
enet_socket_connect (ENetSocket socket, const ENetAddress * address)
{
    int result;
    size_t length = enet_address_get_size (address);
    ENetAddress * clone;

    memcopy (& clone, address, length);
    clone -> port = ENET_HOST_TO_NET_16 (address -> port);

    result = connect (socket, (struct sockaddr *) & clone, length);

    if (result == -1 && errno == EINPROGRESS)
      return 0;
    return result;
}
Ejemplo n.º 20
0
int
enet_socket_connect (ENetSocket socket, const ENetAddress * address)
{
    int result;
    size_t length = enet_address_get_size (address);
    ENetAddress * clone;

    memcopy (& clone, address, length);
    clone -> port = ENET_HOST_TO_NET_16 (address -> port);

    result = connect (socket, (struct sockaddr *) & clone, length);

    if (result == SOCKET_ERROR && WSAGetLastError () != WSAEWOULDBLOCK)
      return -1;

    return 0;
}
Ejemplo n.º 21
0
int handle_scrolling(int offset) {
  if (offset < MAX_ROWS * MAX_COLS*2){
    return offset;
  }

  int i;
  for (i = 1; i < MAX_ROWS; i++){
    memcopy((char*)(get_screen_offset(0, i) + VID_ADDR), (char*)(get_screen_offset(0,i-1) + VID_ADDR), (MAX_COLS * 2));
  }

  char* last_line = (char*) get_screen_offset(0, MAX_ROWS - 1) + VID_ADDR;
  for (i=0; i < MAX_COLS; i++){
    last_line[i] = 0;
  }

  offset -= 2*MAX_COLS;
  return offset;
}
Ejemplo n.º 22
0
void start_task(void *pdata)
{	
	INT8U err;//错误码
	INT8U *pname;
	INT8U len;//名字的长度
	char buffer[16];

	OS_CPU_SR cpu_sr = 0;
	pdata = pdata;

	delay_init(168);

	OS_ENTER_CRITICLE();	//进入临界区 无法被中断打断
	OSTaskCreate(	led0Task, 
			(void *)0, 
			(OS_STK *)LED0_TASK_STK[LED0_STK_SIZE-1],
			LED0_TASK_PRIO);//创建LED任务
	// OSTaskCreate(	beepTask, (void *)0, 
	// 		(OS_STK *)BEEP_TASK_STK[BEEP_STK_SIZE-1],
	// 		BEEP_TASK_PRIO);//创建BEEP任务
	//用OSTaskCreateExt改写
	OSTaskCreateExt(	beepTask, (void *)0,
				(OS_STK *)BEEP_TASK_STK[BEEP_STK_SIZE-1],
				BEEP_TASK_PRIO,
				BEEP_TASK_PRIO,//ID设置为跟优先级一样
				(OS_STK *)BEEP_TASK_STK[0],//栈底指针
				BEEP_STK_SIZE,//堆栈大小
				(void *) 0,//额外参数为空
				OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR//使用任务堆栈检查和清零功能

		)
	OSTaskNameSet(BEEP_TASK_PRIO,(INT8U *)BEEP_NAME,&err);//BEEP_NAME必须为全局变量
	len = OSTaskNameGet(BEEP_TASK_PRIO,&pname,&err)//pname本身为一个指针变量,
	//对pname取地址变成二维指针 
	memcopy(buffer,pname,len);//把pname的内容拷贝到buffer中


	OSTaskSuspend(START_TASK_PRIO);//挂起起始任务
	OS_EXIT_CRITICLE();		//退出临界区 可以被中断打断

	

}
void cMatrixStack::GenerateMatrix(uintf _level)
{	if (_level == 0) return;
	sMatrixStackLevel *l = &level[_level];
	sMatrixStackLevel *p = &level[l->parent];

	if (!p->current) GenerateMatrix(l->parent);

	memcopy(l->mtx, level[l->parent].mtx, sizeof(Matrix));
	movealongx(l->mtx, l->pivot.x);
	movealongy(l->mtx, l->pivot.y);
	movealongz(l->mtx, l->pivot.z);
	if (l->rotx) rotatearoundx(l->mtx, l->rotx);
	if (l->roty) rotatearoundy(l->mtx, l->roty);
	if (l->rotz) rotatearoundz(l->mtx, l->rotz);
	fixrotations(l->mtx);


	l->current = true;
}
Ejemplo n.º 24
0
size_t scatter(void const * memory, size_t extent, struct field const * field, unsigned fields)

{
	byte const * source = (byte const *) (memory);
	while ((fields--) && (field->size < extent))
	{
		if (! field->type)
		{
			memcopy (field->base, source, field->size);
		}
		else 
		{
			memfold (field->base, source, field->size);
		}
		source += field->size;
		extent -= field->size;
		field++;
	}
	return (source - (byte *) (memory));
}
Ejemplo n.º 25
0
//-----------------------------------------------------------------------------
// Name: dx_getvideoinfo
// Desc:
//-----------------------------------------------------------------------------
void xw_getvideoinfo(void *vidinfo)
{	videoinfostruct vi;
	txtcpy(vi.DriverName,sizeof(vi.DriverName),DriverNameUser);
	txtcpy(vi.AuthorName,sizeof(vi.AuthorName),DriverAuthor);
	txtcpy(vi.DriverNameShort,sizeof(vi.DriverNameShort),DriverNameshort);
	txtcpy(vi.LoadingMethod,sizeof(vi.LoadingMethod),"Static");
	txtcpy(vi.DeviceDescription,sizeof(vi.DeviceDescription),"XWindows");
	vi.MaxTextureWidth	= 0;
	vi.MaxTextureHeight	= 0;
	vi.NumTextureUnits	= 0;
	vi.TextureMemory	= 0;
	vi.MaxAnisotropy	= 0;
	vi.Features			= 0;

	videoinfostruct *dest = (videoinfostruct *)vidinfo;
	dword size = dest->structsize;
	if (size>sizeof(videoinfostruct)) size = sizeof(videoinfostruct);
	memcopy(dest,&vi,size);
	dest->structsize = size;
}
Ejemplo n.º 26
0
size_t gather (void * memory, size_t extent, struct field const * field, unsigned fields) 

{
	byte * target = (byte *)(memory);
	while ((fields--) && (field->size < extent)) 
	{
		if (!field->type) 
		{
			memcopy (target, field->base, field->size);
		}
		else 
		{
			memfold (target, field->base, field->size);
		}
		target += field->size;
		extent -= field->size;
		field++;
	}
	return (target - (byte *)(memory));
}
Ejemplo n.º 27
0
vnode_t *get_vnode(uint32_t driver_num, uint32_t inode_num)
{
	vnode_t *vnode = find_vnode(driver_num, inode_num);
	if(!vnode)
	{
		vnode = get_free_vnode();
		vfs_msg_getnode *getnode_msg = (vfs_msg_getnode *)calloc(sizeof(vfs_msg_getnode));
		getnode_msg->msg_type = VFSM_GETNODE;
		getnode_msg->node.driver_num = driver_num;
		getnode_msg->node.inode_num = inode_num;
		send2(driver_num, getnode_msg);
		free(getnode_msg);
		getnode_msg = waitmsg(driver_num,0);
		if(getnode_msg->node.driver_num)
		{
			memcopy((uint8_t *)vnode, (uint8_t *)&getnode_msg->node, sizeof(vnode_t));
		} else {
			_syscall_printf("\nGetnode failed!",0);
		}
		free(getnode_msg);
	}
	return vnode;
}
Ejemplo n.º 28
0
Archivo: sc4.c Proyecto: jte/pawn
/* Address of the source must already have been loaded in PRI
 * "size" is the size in bytes (not cells).
 */
SC_FUNC void copyarray(symbol *sym,cell size)
{
  assert(sym!=NULL);
  /* the symbol can be a local array, a global array, or an array
   * that is passed by reference.
   */
  if (sym->ident==iREFARRAY) {
    /* reference to an array; currently this is always a local variable */
    assert(sym->vclass==sLOCAL);        /* symbol must be stack relative */
    stgwrite("\tload.s.alt ");
  } else {
    /* a local or global array */
    if (sym->vclass==sLOCAL)
      stgwrite("\taddr.alt ");
    else
      stgwrite("\tconst.alt ");
  } /* if */
  outval(sym->addr,TRUE);
  markusage(sym,uWRITTEN);

  code_idx+=opcodes(1)+opargs(1);
  memcopy(size);
}
Ejemplo n.º 29
0
int
enet_socket_send (ENetSocket socket,
                  const ENetAddress * address,
                  const ENetBuffer * buffers,
                  size_t bufferCount)
{
    struct msghdr msgHdr;
    ENetAddress address_clone;
    int sentLength;

    memset (& msgHdr, 0, sizeof (struct msghdr));

    if (address != NULL)
    {
        msgHdr.msg_name = & address_clone;
        msgHdr.msg_namelen = enet_address_get_size (address);

        memcopy (& address_clone, address, msgHdr.msg_namelen);

        address_clone.port = ENET_HOST_TO_NET_16 (address -> port);
    }

    msgHdr.msg_iov = (struct iovec *) buffers;
    msgHdr.msg_iovlen = bufferCount;

    sentLength = sendmsg (socket, & msgHdr, MSG_NOSIGNAL);

    if (sentLength == -1)
    {
       if (errno == EWOULDBLOCK)
         return 0;

       return -1;
    }

    return sentLength;
}
Ejemplo n.º 30
0
size_t  ATTR_FUNC( attr_get )( const uint8_t attr_num, void *const to )
{
    void * from = NULL;
    size_t size = 0;
    uint8_t i;

    // сначала обработка общих атрибутов
    size = common_attr_get(&common_attrs_32773, attr_num, to);
    if (size != 0)
        return size;
        
    // иначе обработка атрибутов данного профиля
    for( i=0; i<TOTAL_ATTRIBUTES; i++ ) 
        if( attributes[i].num == attr_num ) {
            from = attributes[i].ptr;
            size = attributes[i].size;
            break;
        }
    if( TOTAL_ATTRIBUTES <= i )
        return 0;
    
    memcopy(to, from, size);
    return size;
}