int copy_swap_buffer_in	(	FORMAT_STR *	format_data,
		void *	buff_out,
		void *	buff_in,
		int	size
	)

Definition at line 270 of file copy_swap.c.

References _swapd_buffer(), _swapl_buffer(), _swaps_buffer(), check_padding(), Dic_padding, FORMAT_STR::flags, get_curr_bytes(), inc_pter, NOSWAP, FORMAT_STR::par_bytes, FORMAT_STR::par_num, SIZEOF_DOUBLE, SIZEOF_LONG, SIZEOF_SHORT, SWAPD, SWAPL, and SWAPS.

Referenced by execute_command(), and execute_service().

{
        int num, pad_num, curr_size = 0, curr_out = 0;
        int next_par_bytes, curr_par_num, curr_par_bytes;
        
        num = 0;
        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;
                curr_par_bytes = format_data->par_bytes;
                if((curr_size+(curr_par_num * curr_par_bytes))
                   > size)
                {
                        curr_par_num = (size - curr_size)/curr_par_bytes;
                        next_par_bytes = 0;
                }
                switch(format_data->flags & 0x3) 
                {
                        case NOSWAP :

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

                                if(Dic_padding)
                                {
                                        if(curr_par_bytes == SIZEOF_DOUBLE)
                                        {
#ifdef PADD64
                                                if( (pad_num = check_padding(curr_out, SIZEOF_DOUBLE)) )
#else
                                                if( (pad_num = check_padding(curr_out, SIZEOF_LONG)) )
#endif
                                                {
                                                        inc_pter( buff_out, pad_num);
                                                        curr_out += pad_num;
                                                }
                                        }
                                        else
                                        {
                                                if( (pad_num = check_padding(curr_out, curr_par_bytes)) )
                                                {
                                                        inc_pter( buff_out, pad_num);
                                                        curr_out += pad_num;
                                                }
                                        }
                                }

                                if(buff_in != buff_out)
                                        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(Dic_padding)
                                {
                                        if( (pad_num = check_padding(curr_out, SIZEOF_SHORT)) )
                                        {
                                                inc_pter( buff_out, pad_num);
                                                curr_out += pad_num;
                                        }
                                }
                                _swaps_buffer( (short *)buff_out, (short *)buff_in, num/SIZEOF_SHORT) ;
                                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(Dic_padding)
                                {
                                        if( (pad_num = check_padding(curr_out, SIZEOF_LONG)) )
                                        {
                                                inc_pter( buff_out, pad_num);
                                                curr_out += pad_num;
                                        }
                                }
                                _swapl_buffer( (short *)buff_out, (short *)buff_in, num/SIZEOF_LONG) ;
                                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(Dic_padding)
                                {
#ifdef PADD64
                                        if( (pad_num = check_padding(curr_out, SIZEOF_DOUBLE)) )
#else
                                        if( (pad_num = check_padding(curr_out, SIZEOF_LONG)) )
#endif
                                        {
                                                inc_pter( buff_out, pad_num);
                                                curr_out += pad_num;
                                        }
                                }
                                _swapd_buffer( (short *)buff_out, (short *)buff_in, num/SIZEOF_DOUBLE) ;
                                inc_pter( buff_in, num);
                                inc_pter( buff_out, num);
                                curr_out += num;
                                break;
                }
#ifdef vms
                check_vms_in(format_data->flags, curr_par_num, curr_par_bytes, 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: