int copy_swap_buffer_out	(	int	format,
		FORMAT_STR *	format_data,
		void *	buff_out,
		void *	buff_in,
		int	size
	)

Definition at line 170 of file copy_swap.c.

References check_padding(), Dis_padding, FORMAT_STR::flags, get_curr_bytes(), inc_pter, NOSWAP, FORMAT_STR::par_bytes, FORMAT_STR::par_num, SIZEOF_CHAR, SIZEOF_DOUBLE, SIZEOF_LONG, SIZEOF_SHORT, SWAPD, SWAPL, and SWAPS.

Referenced by execute_service(), and send_command().

{
        int num = 0, pad_num = 0, curr_size = 0, curr_out = 0;
        int next_par_bytes, curr_par_num;
        
        if(format){}
        if(!format_data->par_bytes) {
                if(buff_in != buff_out)
                        memcpy( buff_out, buff_in, (size_t)size );
                return(size);
        }
        next_par_bytes = format_data->par_bytes;
        while(next_par_bytes)
        {
                curr_par_num = format_data->par_num;
                if((curr_size+(curr_par_num * format_data->par_bytes))
                   > size)
                {
                        curr_par_num = (size - curr_size)/format_data->par_bytes;
                        next_par_bytes = 0;
                }
                switch(format_data->flags & 0x3) 
                {
                        case NOSWAP :

                                num = get_curr_bytes(curr_par_num,
                                        size - curr_size, SIZEOF_CHAR);

                                memcpy( buff_out, buff_in, (size_t)num);
                                inc_pter( buff_in, num);
                                inc_pter( buff_out, num);
                                curr_out += num;
                                break;
                        case SWAPS :
                                num = get_curr_bytes(curr_par_num,
                                        size - curr_size, SIZEOF_SHORT);

                                if(Dis_padding)
                                {
                                        if( (pad_num = check_padding(curr_size, SIZEOF_SHORT)) )
                                        {
                                                inc_pter( buff_in, pad_num);
                                                curr_size += pad_num;
                                        }
                                }
                                memcpy( buff_out, buff_in, (size_t)num);
                                inc_pter( buff_in, num);
                                inc_pter( buff_out, num);
                                curr_out += num;
                                break;
                        case SWAPL :
                                num = get_curr_bytes(curr_par_num,
                                        size - curr_size, SIZEOF_LONG);

                                if(Dis_padding)
                                {
                                        if( (pad_num = check_padding(curr_size, SIZEOF_LONG)) )
                                        {
                                                inc_pter( buff_in, pad_num);
                                                curr_size += pad_num;
                                        }
                                }
                                memcpy( buff_out, buff_in, (size_t)num);
                                inc_pter( buff_in, num);
                                inc_pter( buff_out, num);
                                curr_out += num;
                                break;
                        case SWAPD :
                                num = get_curr_bytes(curr_par_num,
                                        size - curr_size, SIZEOF_DOUBLE);

                                if(Dis_padding)
                                {
#ifdef PADD64
                                        if( (pad_num = check_padding(curr_size, SIZEOF_DOUBLE)) )
#else
                                        if( (pad_num = check_padding(curr_size, SIZEOF_LONG)) )
#endif
                                        {
                                                inc_pter( buff_in, pad_num);
                                                curr_size += pad_num;
                                        }
                                }
                                memcpy( buff_out, buff_in, (size_t)num);
                                inc_pter( buff_in, num);
                                inc_pter( buff_out, num);
                                curr_out += num;
                                break;
                }
#ifdef vms
                check_vms_out(format_data->flags, format, curr_par_num, buff_out);
#endif
                curr_size += num;
                format_data++;
                if(next_par_bytes)
                        next_par_bytes = format_data->par_bytes;
        }
        return(curr_out);
}

Here is the call graph for this function:

Here is the caller graph for this function: